import junit.framework.TestCase;

// Class: TestAnyCS210OrderedListImplementation
//
// Author: Alyce Brady 
//
// Created on Oct 6, 2006
// Modified on April 23, 2008, Pam Cutter
//    Adapted to fit with List ADT as specified in class S08.
// Modified on October 14, 2008, Pam Cutter
//    Adapted to fit with OrderedListADT, as specified in class 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>TestAnyCS210OrderedListImplementation</code> object 
 *  tests the various methods of any class implementing the 
 *  <code>CS210OrderedListADT</code> interface.
 *
 *  @author Alyce Brady, Pam Cutter
 *  @version Oct 6, 2006
 *  @version April 23, 2008
 */
public abstract class TestAnyCS210OrderedListImplementation extends TestCase
{
    public TestAnyCS210OrderedListImplementation(String name)
    {
        super(name);
    }
    
    public abstract CS210OrderedListADT<Integer> makeEmptyIntegerList();
    
    public abstract CS210OrderedListADT<Integer> makeAListWithNoDuplicates();
    
    public abstract CS210OrderedListADT<Integer> makeAnotherListWithNoDuplicates();
    
    public abstract CS210OrderedListADT<Integer> makeSingleElementList();

    public abstract CS210OrderedListADT<Integer> makeAListWithDuplicates();
    
    public abstract CS210OrderedListADT<Integer> makeAnotherListWithDuplicates();
    
    public abstract CS210OrderedListADT<Integer> makeListWithTwoElements();
    
    public abstract CS210OrderedListADT<Integer> makeAnotherListWithTwoElements();
    
    public void testAddWithEmptyList()
    {
        CS210OrderedListADT<Integer> list = makeEmptyIntegerList();
        list.add(3);
        assertEquals(makeSingleElementList(), list);
    }
    
    public void testAddToEndSingleElementList()
    {
        CS210OrderedListADT<Integer> list = makeSingleElementList();
        list.add(12);
        assertEquals(makeListWithTwoElements(), list);
    }
    
    public void testAddToEndMultiElementList()
    {
        CS210OrderedListADT<Integer> list = makeAListWithNoDuplicates();
        list.add(20);
        assertEquals("[3, 5, 8, 12, 20]", list.toString());
    }
    
    public void testAddInFrontOfSingleEltList()
    {
        CS210OrderedListADT<Integer> list = makeSingleElementList();
        list.add(2);
        assertEquals(makeAnotherListWithTwoElements(), list);
    }
    
    public void testAddWithADuplicateElement()
    {
        CS210OrderedListADT<Integer> list = makeListWithTwoElements();
        list.add(3);
        assertEquals(makeAListWithDuplicates(), list);
    }
    
    public void testAddInFrontOfMultiEltList()
    {
        CS210OrderedListADT<Integer> list = makeAListWithNoDuplicates();
        list.add(2);
        assertEquals(makeAnotherListWithNoDuplicates(), list);
    }
    
    public void testAddInMiddleOfMultiEltList()
    {
        CS210OrderedListADT<Integer> list = makeAListWithNoDuplicates();
        list.add(8);
        assertEquals(makeAnotherListWithDuplicates(), list);
    }
    
    public void testAddAllFromEmptyListToEmptyList()
    {
        CS210OrderedListADT<Integer> fromList = makeEmptyIntegerList();
        CS210OrderedListADT<Integer> toList = makeEmptyIntegerList();
        toList.addAll(fromList);
        assertEquals(makeEmptyIntegerList(), toList);
    }

    public void testAddAllFromListWithMultElementsToEmptyList()
    {
        CS210OrderedListADT<Integer> fromList = makeAListWithDuplicates();
        CS210OrderedListADT<Integer> toList = makeEmptyIntegerList();
        toList.addAll(fromList);
        assertEquals(fromList, toList);
    }

    public void testAddAllFromListWithMultElementsToListNoDuplicates()
    {
        CS210OrderedListADT<Integer> fromList = makeEmptyIntegerList();
        fromList.add(12);
        fromList.add(8);
        CS210OrderedListADT<Integer> toList = makeEmptyIntegerList();
        toList.add(5);
        toList.add(3);
        toList.addAll(fromList);
        CS210ListADT<Integer> controlList = makeAListWithNoDuplicates();
        assertEquals(controlList, toList);
    }

    public void testAddAllFromListWithMultElementsToListWithDuplicates()
    {
        CS210OrderedListADT<Integer> fromList = makeEmptyIntegerList();
        fromList.add(12);
        fromList.add(3);
        fromList.add(8);
        CS210OrderedListADT<Integer> toList = makeEmptyIntegerList();
        toList.add(5);
        toList.add(8);
        toList.addAll(fromList);
        CS210OrderedListADT<Integer> controlList = makeAnotherListWithDuplicates();
        assertEquals(controlList, toList);
    }
    
    
   
}