AbstractLinkedListTest.java

package org.apache.commons.collections4.list;

import org.junit.Test;

/** 
 * Test case for {@link AbstractLinkedList}.
 * 
 * @version $Id$
 */
public abstract class AbstractLinkedListTest<E> extends AbstractListTest<E> {
    public AbstractLinkedListTest(final String testName) {
        super(testName);
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_add625() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_add625");
        resetEmpty();
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_add626() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_add626");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_add627() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_add627");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_add628() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_add628");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_add629() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_add629");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_add630() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_add630");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_add631() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_add631");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_add632() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_add632");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_add633() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_add633");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_add634() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_add634");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveFirst() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveFirst_literalMutation707() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_literalMutation707");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "foo" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveFirst_literalMutation708() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_literalMutation708");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "foo" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveFirst_literalMutation709() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_literalMutation709");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("foo")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveFirst_literalMutation710() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_literalMutation710");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("foo")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_remove498() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_remove498");
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_remove499() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_remove499");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_remove500() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_remove500");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_remove501() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_remove501");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_remove502() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_remove502");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_remove503() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_remove503");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_remove504() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_remove504");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_remove505() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_remove505");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveFirst_remove506() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveFirst_remove506");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeFirst();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2026,list,2025,list.removeFirst());
        list.addLast(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2028,list,2027,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2030,list,2029,list.removeFirst());
        checkNodes();
        list.addLast(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2032,list,2031,list.removeFirst());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_add635() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_add635");
        resetEmpty();
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_add636() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_add636");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_add637() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_add637");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_add638() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_add638");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_add639() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_add639");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_add640() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_add640");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_add641() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_add641");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveLast() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveLast_literalMutation712() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_literalMutation712");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "foo" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveLast_literalMutation713() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_literalMutation713");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "foo" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveLast_literalMutation714() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_literalMutation714");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("foo")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveLast_literalMutation715() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_literalMutation715");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("foo")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_remove507() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_remove507");
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_remove508() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_remove508");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_remove509() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_remove509");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_remove510() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_remove510");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_remove511() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_remove511");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveLast_remove512() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveLast_remove512");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isRemoveSupported())) {
            try {
                list.removeLast();
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2034,list,2033,list.removeLast());
        list.addFirst(((E)("value3")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2036,list,2035,list.removeLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2038,list,2037,list.removeLast());
        list.addFirst(((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2040,list,2039,list.removeFirst());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add602() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add602");
        resetEmpty();
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add603() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add603");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add604() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add604");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add605() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add605");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add606() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add606");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add607() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add607");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add608() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add608");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add609() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add609");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add610() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add610");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add611() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add611");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add612() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add612");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_add613() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_add613");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation679() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation679");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("foo")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation680() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation680");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(1, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation681() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation681");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, true), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation682() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation682");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("foo")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation683() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation683");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(-1, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation684() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation684");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, true), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation685() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation685");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("foo")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation686() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation686");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(-1, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation687() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation687");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, true), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation688() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation688");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("foo")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation689() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation689");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(3, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation690() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation690");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testAddNodeAfter_literalMutation691() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_literalMutation691");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("foo")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove480() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove480");
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove481() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove481");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove482() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove482");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove483() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove483");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove484() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove484");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove485() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove485");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove486() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove486");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove487() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove487");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove488() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove488");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove489() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove489");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        checkNodes();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testAddNodeAfter_remove490() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testAddNodeAfter_remove490");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        if (!(isAddSupported())) {
            try {
                list.addFirst(null);
            } catch (final UnsupportedOperationException ex) {
            }
        } 
        list.addFirst(((E)("value1")));
        list.addNodeAfter(list.getNode(0, false), ((E)("value2")));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2002,list,2001,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2004,list,2003,list.getLast());
        list.removeFirst();
        list.addNodeAfter(list.getNode(0, false), ((E)("value3")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2006,list,2005,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2008,list,2007,list.getLast());
        list.addNodeAfter(list.getNode(0, false), ((E)("value4")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2010,list,2009,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2012,list,2011,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2014,list,2013,list.get(1));
        list.addNodeAfter(list.getNode(2, false), ((E)("value5")));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2016,list,2015,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2018,list,2017,list.get(1));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2020,list,2019,list.get(2));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2022,list,2021,list.getLast());
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add642() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add642");
        resetEmpty();
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add643() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add643");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add644() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add644");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add645() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add645");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add646() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add646");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add647() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add647");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add648() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add648");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add649() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add649");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add650() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add650");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add651() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add651");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_add652() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_add652");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode_literalMutation717() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_literalMutation717");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "foo" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode_literalMutation718() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_literalMutation718");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "foo" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode_literalMutation719() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_literalMutation719");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(-1, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode_literalMutation720() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_literalMutation720");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, true));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode_literalMutation721() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_literalMutation721");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("foo")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode_literalMutation722() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_literalMutation722");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("foo")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode_literalMutation723() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_literalMutation723");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(2, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode_literalMutation724() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_literalMutation724");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode_literalMutation725() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_literalMutation725");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(2, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testRemoveNode_literalMutation726() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_literalMutation726");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, true));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove513() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove513");
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove514() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove514");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove515() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove515");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove516() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove516");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove517() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove517");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove518() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove518");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove519() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove519");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove520() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove520");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove521() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove521");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove522() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove522");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testRemoveNode_remove523() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testRemoveNode_remove523");
        resetEmpty();
        if ((!(isAddSupported())) || (!(isRemoveSupported()))) {
            return ;
        } 
        final AbstractLinkedList<E> list = getCollection();
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.removeNode(list.getNode(0, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2042,list,2041,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2044,list,2043,list.getLast());
        list.addFirst(((E)("value1")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2046,list,2045,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2048,list,2047,list.getLast());
        checkNodes();
        list.removeNode(list.getNode(1, false));
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2050,list,2049,list.getFirst());
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2052,list,2051,list.getLast());
        checkNodes();
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add614() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add614");
        resetEmpty();
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add615() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add615");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add616() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add616");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add617() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add617");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add618() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add618");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add619() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add619");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add620() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add620");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add621() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add621");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add622() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add622");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add623() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add623");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_add624() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_add624");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation693() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation693");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation694() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation694");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation695() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation695");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "foo" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation696() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation696");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "foo" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation697() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation697");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("foo")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation698() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation698");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(0, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation699() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation699");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, true));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation700() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation700");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(3, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation701() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation701");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation702() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation702");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation703() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation703");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation704() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation704");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(2, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    public void testGetNode_literalMutation705() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_literalMutation705");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_remove491() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_remove491");
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_remove492() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_remove492");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_remove493() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_remove493");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_remove494() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_remove494");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_remove495() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_remove495");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_remove496() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_remove496");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        checkNodes();
        list.addFirst(((E)("value0")));
        checkNodes();
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    @SuppressWarnings(value = "unchecked")
    @Test(timeout = 1000)
    public void testGetNode_remove497() {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testGetNode_remove497");
        resetEmpty();
        final AbstractLinkedList<E> list = getCollection();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2023,list.getNode(0, true).previous);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2024,list.getNode(0, true).next);
        try {
            list.getNode(0, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        list.addAll(java.util.Arrays.asList(((E[])(new String[]{ "value1" , "value2" }))));
        list.addFirst(((E)("value0")));
        checkNodes();
        list.removeNode(list.getNode(1, false));
        checkNodes();
        try {
            list.getNode(2, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(-1, false);
        } catch (final IndexOutOfBoundsException ex) {
        }
        try {
            list.getNode(3, true);
        } catch (final IndexOutOfBoundsException ex) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    protected void checkNodes() {
        final AbstractLinkedList<E> list = getCollection();
        for (int i = 0 ; i < (list.size) ; i++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1995,list.getNode(i, false).next);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1997,list,1996,list.getNode((i + 1), true));
            if (i < ((list.size) - 1)) {
                fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1998,list.getNode((i + 1), false).previous);
                fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),2000,list,1999,list.getNode(i, false));
            } 
        }
    }

    /** 
     * {@inheritDoc}
     */
@Override
    public AbstractLinkedList<E> getCollection() {
        return ((AbstractLinkedList<E>)(super.getCollection()));
    }
}