/**
 * instructor's tester code for A04.
 * 
 * @author Pikalek
 * @version (a version number or a date)
 */
public class PikalekA04Tester
{
    /**
     * main program starts here
     * runs a battery of tests against the DoubleArraySequence class
     * param args - ignored
     */
    public static void main(String args[])
    {
        emptyTest();
        addAfterTest();
        addBeforeTest();
        startTest();
        advanceOkayTest();
        advanceFailTest();
        removeOkayTest();
        removeFailTest();
        trimTest();
        addAllSeperateTest();
        addAllSelfTest();
        catenationRegTest();
        catenationEmptyTest();
       
    }
    /**
     * check the result of examining an empty sequence
     */
    public static void emptyTest()
    {
        System.out.println("\n***********emptyTest()");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            displaySequence(s0);
            System.out.println("\nExpected:");
            displayExpected(new double[0], Double.NaN, 10);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
    }
    /**
     * use addAfter & check the results
     */
    public static void addAfterTest()
    {
        System.out.println("\n***********addAfterTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.addAfter(1);
            s0.addAfter(2);
            s0.addAfter(4);
            s0.addAfter(6);
            displaySequence(s0);
            System.out.println("\nExpected:");
            displayExpected(new double[] {1,2,4,6}, 1, 10);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
    }
    /**
     * use addBefore & check the results
     * also tests using the non default constructor
     */
    public static void addBeforeTest()
    {
        System.out.println("\n***********addBeforeTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(8);
            s0.addBefore(1);
            s0.addBefore(3);
            s0.addBefore(5);
            s0.addBefore(7);
            displaySequence(s0);
            System.out.println("\nExpected:");
            displayExpected(new double[] {7,5,3,1}, 7, 8);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
    }
    /**
     * test moving to the start of a sequence
     */
    public static void startTest()
    {
        System.out.println("\n***********startTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.addAfter(1);
            s0.addBefore(2);
            s0.addAfter(3);
            s0.addBefore(4);
            s0.addAfter(5);
            s0.start();
            displaySequence(s0);
            System.out.println("\nExpected:");
            displayExpected(new double[] {2,4,5,3,1}, 2, 10);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
    }
    /**
     * test advancing safely through a sequence
     */
    public static void advanceOkayTest()
    {
        System.out.println("\n***********advanceOkayTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.addBefore(1);
            s0.addBefore(2);
            s0.addBefore(3);
            s0.addBefore(4);
            s0.advance();
            s0.advance();
            displaySequence(s0);
            System.out.println("\nExpected:");
            displayExpected(new double[] {4,3,2,1}, 2, 10);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
   }
   /**
    * check moving past the end of a sequence - should throw an exception
    */
    public static void advanceFailTest()
    {
        System.out.println("\n***********advanceFailTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.advance();
        }
        catch(Exception e)
        {
            System.out.println("result: " + e);
        }
        System.out.println(    "Expected: IllegalStateException");
    }
    /**
     * test safely removing an element
     */
    public static void removeOkayTest()
    {
        System.out.println("\n***********removeOkayTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.addBefore(1);
            s0.addBefore(2);
            s0.addBefore(3);
            s0.addBefore(4);
            s0.removeCurrent();
            displaySequence(s0);
            System.out.println("\nExpected:");
            displayExpected(new double[] {3,2,1}, 3, 10);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
    }
    /**
     * test removing something that isn't there - should throw an exception
     */
    public static void removeFailTest()
    {
        System.out.println("\n***********removeFailTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.removeCurrent();
        }
        catch(Exception e)
        {
            System.out.println("result: " + e);
        }
        System.out.println(    "Expected: IllegalStateException");
    }
    /**
     * test trimming the unused spots from a sequence
     */
    public static void trimTest()
    {
        System.out.println("\n***********trimTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.addBefore(1);
            s0.addBefore(2);
            s0.addBefore(3);
            s0.trimToSize();
            displaySequence(s0);
            System.out.println("\nExpected:");
            displayExpected(new double[] {3,2,1}, 3, 3);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
    }
    /**
     * test add all using two seperate sequences
     */
    public static void addAllSeperateTest()
    {
        System.out.println("\n***********addAllSeperateTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.addBefore(1);
            s0.addBefore(2);
            s0.addBefore(3);
            DoubleArraySeq s1 = new DoubleArraySeq(10);
            s1.addBefore(-1);
            s1.addBefore(-2);
            s1.addBefore(-3);
            s0.addAll(s1);
            displaySequence(s0);
            System.out.println("\nExpected s0:");
            displayExpected(new double[] {3,2,1,-3,-2,-1}, 3, 10);
            displaySequence(s1);
            System.out.println("\nExpected s1:");
            displayExpected(new double[] {-3,-2,-1}, -3, 10);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
    }
    /**
     * try using addAll to add a sequence to itself
     */
    public static void addAllSelfTest()
    {
        System.out.println("\n***********addAllSelfTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.addBefore(1);
            s0.addBefore(2);
            s0.addBefore(3);
            s0.addAll(s0);
            displaySequence(s0);
            System.out.println("\nExpected:");
            displayExpected(new double[] {3,2,1,3,2,1}, 3, 10);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
    }
    /**
     * test regular concatenation (that is, w/ two seperate sequences)
     */
    public static void catenationRegTest()
    {
        System.out.println("\n***********catenationRegTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.addAfter(1);
            s0.addAfter(3);
            s0.addAfter(5);
            DoubleArraySeq s1 = new DoubleArraySeq(10);
            s1.addAfter(2);
            s1.addAfter(4);
            s1.addAfter(6);
            DoubleArraySeq s2 = DoubleArraySeq.catenation(s0,s1);
            displaySequence(s0);
            System.out.println("\nExpected s0:");
            displayExpected(new double[] {1,3,5}, 5, 10);
            displaySequence(s1);
            System.out.println("\nExpected s1:");
            displayExpected(new double[] {2,4,6}, 6, 10);
            displaySequence(s2);
            System.out.println("\nExpected s2:");
            displayExpected(new double[] {1,3,5,2,4,6}, Double.NaN, 10);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
    }
    /**
     * test concatenating a normal sequence with an empty one
     */
    public static void catenationEmptyTest()
    {
        System.out.println("\n***********catenationEmptyTest");
        try
        {
            DoubleArraySeq s0 = new DoubleArraySeq(10);
            s0.addAfter(1);
            s0.addAfter(3);
            s0.addAfter(5);
            DoubleArraySeq s1 = new DoubleArraySeq(10);
            DoubleArraySeq s2 = DoubleArraySeq.catenation(s0,s1);
            displaySequence(s0);
            System.out.println("\nExpected s0:");
            displayExpected(new double[] {1,3,5}, 5, 10);
            displaySequence(s1);
            System.out.println("\nExpected s1:");
            displayExpected(new double[] {}, Double.NaN, 10);
            displaySequence(s2);
            System.out.println("\nExpected s2:");
            displayExpected(new double[] {1,3,5}, Double.NaN, 10);
        }
        catch(Exception e)
        {
            System.out.println("\n\tresult: unexpected " + e);
        }
    }
    /**
     * display a sequence, including current element, all elements,
     * capacity & size
     * note: invalid elements are displayed as Double.NaN
     * note: the sequence currentIndex will be modified - use with care or with clones
     * @param s the seqeuence to display
     */
    public static void displaySequence(DoubleArraySeq s)
    {
        double cur = Double.NaN;
        if(s.isCurrent())
            cur = s.getCurrent();
        System.out.println("\ncurrent element: " + cur);
        System.out.println("capacity:        " + s.getCapacity());
        System.out.println("size:            " + s.size());
        int a=0;
        s.start();
        System.out.print("data: ");
        while(s.isCurrent() && a<s.size()*2)
        {
            System.out.print(" " + s.getCurrent());
            s.advance();
            a++;
        }
    }
    /**
     * display expected seqeunce results, including current element, all elements,
     * capacity & size
     * note: invalid currentElement should be entered as Double.NaN
     * @param array the ordered elements of the sequence starting w/ array[0]
     * @param cur   the current element of the sequence
     * @param cap   the current capacity of the sequence
     */
    public static void displayExpected(double[] array, double cur, int cap)
    {
        System.out.println("current element: " + cur);
        System.out.println("capacity:        " + cap);
        System.out.println("size:            " + array.length);
        System.out.print("data: ");
        for(double e : array)
        {
            System.out.print(" " + e);
        }
    }
}