import java.util.Iterator;

import junit.framework.TestCase;

// Class: TestAnyCS210ListImplementation
//
// Author: Alyce Brady 
//
// Created on Oct 6, 2006
//
// Modifier: Pam Cutter
//      October 16, 2007: Edited names to correspond to CS210 F07
//                        names for methods & List interface.
//      April 22, 2008: Edited to work with CS210ListADT S08
//      October 14, 2008: Edited to work with CS210ListADT F08
//Modifier: Nathan Sprague
//      Oct. 11, 2009 Edited to work with CS210ListADT F09
//
// License Information:
//   This class is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation.
//
//   This class is distributed in the hope that it will be useful,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//   GNU General Public License for more details.

/**
 *  A <code>TestAnyCS210ListImplementation</code> object 
 *  tests the various methods of any class implementing the
 *  <code>CS210List interface.
 *
 *  @author Alyce Brady, Pam Cutter
 *  @version Oct 13, 2008
 */
public abstract class TestAnyCS210ListImplementation extends TestCase
{
    public TestAnyCS210ListImplementation(String name)
    {
        super(name);
    }

    public abstract CS210ListADT<Integer> makeEmptyIntegerList();
    
    public abstract CS210ListADT<Integer> makeAListWithNoDuplicates();
    
    public abstract CS210ListADT<Integer> makeAListWithNoDuplicatesInReverse();
    
    public abstract CS210ListADT<Integer> makeAListWithDuplicates();
    
    public abstract CS210ListADT<Integer> makeSingleElementList();
    
    public abstract CS210ListADT<Integer> makeLongerListWithNoDuplicates();
    
    public abstract CS210ListADT<Integer> makeListWithNoDuplicatesWithoutSecondElt();
    
    public void testConstructorAndToStringOnEmptyList()
    {
        CS210ListADT<Integer> list = makeEmptyIntegerList();
        assertEquals("[ ]", list.toString());
    }


    public void testIsEmptyOnEmptyList()
    {
        CS210ListADT<Integer> list = makeEmptyIntegerList();
        assertEquals(true, list.isEmpty());
    }

    public void testIsEmptyOnNonEmptyList()
    {
        CS210ListADT<Integer> list = makeAListWithNoDuplicates();
        assertEquals(false, list.isEmpty());
    }
    
    public void testSizeOnNonEmptyList()
    {
        // Test list has no duplicates so there's no ambiguity
        // about what size should return.
        CS210ListADT<Integer> list = makeAListWithNoDuplicates();
        assertEquals(4, list.size());
    }

    public void testSizeOnEmptyList()
    {
        CS210ListADT<Integer> list = makeEmptyIntegerList();
        assertEquals(0, list.size());
    }


    public void testIteratingThroughEmptyList()
    {
        CS210ListADT<Integer> listToTest = makeEmptyIntegerList();
        assertEquals(false, listToTest.iterator().hasNext());
    }
  
    /** Tests contains on empty list. */
    public void testContainsOnEmptyList()
    {
        CS210ListADT<Integer> listToTest = makeEmptyIntegerList();
        assertEquals(false, listToTest.contains(3));
    }

    /** Tests contains when object is first in list. */
    public void testContainsOnFirstObjInList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        assertEquals(true, listToTest.contains(3));
    }

    /** Tests contains when object is last in list. */
    public void testContainsOnLastObjInList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        assertEquals(true, listToTest.contains(12));
    }

    /** Tests contains when object is in middle of list. */
    public void testContainsOnMiddleObjInList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        assertEquals(true, listToTest.contains(5));
    }
    
    /** Tests contains when object is not in non-empty list. */
    public void testContainsOnObjNotInList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        assertEquals(false, listToTest.contains(42));
    }
    
    /** Tests clear on empty list. */
    public void testClearOnEmptyList()
    {
        CS210ListADT<Integer> listToTest = makeEmptyIntegerList();
        listToTest.clear();
        assertEquals(makeEmptyIntegerList(), listToTest);
    }
    
    /** Tests clear on list with one element. */
    public void testClearOnListWith1Element()
    {
        CS210ListADT<Integer> listToTest = makeSingleElementList();
        listToTest.clear();
        assertEquals(makeEmptyIntegerList(), listToTest);
    }

    /** Tests clear on list with multiple elements. */
    public void testClearOnListWithMultElements()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        listToTest.clear();
        assertEquals(makeEmptyIntegerList(), listToTest);
    }
    

    //  Do not need to test getFirst on an empty list because it has
    // a pre-condition that the list not be empty.

    public void testFirstOnListWith1Element()
    {
        CS210ListADT<Integer> list = makeSingleElementList();
        assertEquals(3, list.first().intValue());
    }

    public void testFirstOnListWithMultElements()
    {
        CS210ListADT<Integer> list = makeAListWithNoDuplicates();
        assertEquals(3, list.first().intValue());
    }
    
//  Do not need to test getLast on an empty list
    // because both have a pre-condition that the list not be empty.

    public void testLastOnListWith1Element()
    {
        CS210ListADT<Integer> list = makeSingleElementList();
        assertEquals(3, list.last().intValue());
    }

    public void testLastOnListWithMultElements()
    {
        CS210ListADT<Integer> list = makeAListWithNoDuplicates();
        assertEquals(12, list.last().intValue());
    }
    
    public void testFirstNextIteratingThroughNonEmptyList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        int firstVal = listToTest.iterator().next();
        assertEquals(3, firstVal);
    }

    public void testPenultimateNextIteratingThroughNonEmptyList()
    {
        CS210ListADT<Integer> list = makeAListWithNoDuplicates();
        Integer penultimate = null, last = null;
        Iterator<Integer> it = list.iterator();
        while ( it.hasNext() )
        {
            penultimate = last;
            last = it.next();
        }
        assertEquals(8, penultimate.intValue());
    }
    
    public void testLastNextIteratingThroughNonEmptyList()
    {
        CS210ListADT<Integer> list = makeAListWithNoDuplicates();
        Integer last = null;
        Iterator<Integer> it = list.iterator();
        while ( it.hasNext() )
            last = it.next();
        assertEquals(12, last.intValue());
    }

    public void testForEachConstruct()
    {
        CS210ListADT<Integer> list = makeAListWithNoDuplicates();
        int count = 0;
        for ( Integer last : list )
            count++;
        assertEquals(list.size(), count);
    }
    
    //  Do not need to test remove on empty list, nor two removes in a row;
    // both are illegal.
    public void testIteratorRemoveFirstElementInList()
    {
        CS210ListADT<Integer> list = makeSingleElementList();
        Iterator<Integer> it = list.iterator();
        Integer firstItem = it.next();
        it.remove();
        assertEquals(makeEmptyIntegerList(), list);        
    }

    public void testIteratorRemoveLastElementInList()
    {
        CS210ListADT<Integer> list = makeAListWithNoDuplicates();
        //list.addLast(10);
        String rep = "[";
        Iterator<Integer> it = list.iterator();
        for ( int i = 0; i < list.size()-2; i++ )
            rep = rep+it.next()+", ";
        rep = rep+it.next();
        rep = rep+"]";
        it.next();
        it.remove();
        assertEquals(rep, list.toString());        
    }

    public void testIteratorRemoveMiddleElementInList()
    {
        CS210ListADT<Integer> list = makeAListWithNoDuplicates();
        Iterator<Integer> it = list.iterator();
        it.next();
        it.next();
        it.remove();
        assertEquals(makeListWithNoDuplicatesWithoutSecondElt(), list);        
    }

    public void testIteratorRemoveNextRemove()
    {
        CS210ListADT<Integer> list = makeLongerListWithNoDuplicates();
        Iterator<Integer> it = list.iterator();
        // Remove first two elements in list.
        Integer item = it.next();
        it.remove();
        item = it.next();
        it.remove();
        assertEquals("[8, 10, 12, 20]", list.toString());        
    }
    
    public void testRemoveFirstOnListWith1Elt()
    {
        CS210ListADT<Integer> listToTest = makeSingleElementList();
        listToTest.removeFirst();
        assertEquals(makeEmptyIntegerList(), listToTest);
    }

    public void testRemoveFirstOnListWithMultElts()
    {
        CS210ListADT<Integer> listToTest = makeAListWithDuplicates();
        //listToTest.addFirst(42);
        //listToTest.addAll(makeAListWithNoDuplicates());
        listToTest.removeFirst();
        assertEquals(makeAListWithNoDuplicates(), listToTest);
    }

    public void testRemoveLastOnListWith1Elt()
    {
        CS210ListADT<Integer> listToTest = makeSingleElementList();
        listToTest.removeLast();
        assertEquals(makeEmptyIntegerList(), listToTest);
    }

    public void testRemoveLastOnListWithMultElts()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        //listToTest.addLast(42);
        listToTest.removeLast();
        assertEquals("[3, 5, 8]", listToTest.toString());
    }
    
    /** Tests remove when object is first in list. */
    public void testRemoveResultOnFirstObjInList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        //listToTest.addFirst(42);
        assertEquals(true, listToTest.remove(listToTest.first()));
    }

    /** Tests remove when object is last in list. */
    public void testRemoveResultOnLastObjInList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        //listToTest.addLast(42);
        assertEquals(true, listToTest.remove(listToTest.last()));
    }

    /** Tests remove when object is last in list. */
    public void testRemoveResultOnObjInMiddleOfList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        //listToTest.addLast(42);
        assertEquals(true, listToTest.remove(12));
    }
    
    /** Tests remove when object is not in in non-empty list. */
    public void testRemoveResultOnObjNotInList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        assertEquals(null, listToTest.remove(42));
    }

    /** Tests remove when object is first in list. */
    public void testRemoveEffectOnFirstObjInList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithDuplicates();
        listToTest.remove(listToTest.first());
        assertEquals(makeAListWithNoDuplicates(), listToTest);
    }

    /** Tests remove when object is last in list. */
    public void testRemoveEffectOnLastObjInList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        //listToTest.addLast(42);
        listToTest.remove(listToTest.last());
        assertEquals("[3, 5, 8]", listToTest.toString());
    }

    /** Tests remove when object is not in in non-empty list. */
    public void testRemoveEffectOnObjNotInList()
    {
        CS210ListADT<Integer> listToTest = makeAListWithNoDuplicates();
        listToTest.remove(42);
        assertEquals(makeAListWithNoDuplicates(), listToTest);
    }
    
    public void testRemoveAllWithSingleElt()
    {
    	CS210ListADT<Integer> list = makeAListWithNoDuplicates();
    	CS210ListADT<Integer> listToRemove = makeSingleElementList();
    	list.removeAll(listToRemove);
    	CS210ListADT<Integer> controlList = makeAListWithNoDuplicates();
    	controlList.remove(listToRemove.first());
    	assertEquals(controlList,list);
    }
    
    public void testRemoveAllWithSingleRepeatedElt()
    {
    	CS210ListADT<Integer> list = makeAListWithDuplicates();
    	CS210ListADT<Integer> listToRemove = makeSingleElementList();
    	list.removeAll(listToRemove);
    	CS210ListADT<Integer> controlList = makeAListWithNoDuplicates();
    	controlList.remove(listToRemove.first());
    	assertEquals(controlList,list);
    }
    
    public void testRemoveAllWithAllObjectsInList()
    
    {
    	CS210ListADT<Integer> list = makeAListWithDuplicates();
    	CS210ListADT<Integer> listToRemove = makeAListWithNoDuplicates();
    	list.removeAll(listToRemove);
    	assertEquals(makeEmptyIntegerList(),list);
    }
    

}