/*
 * TODO: Test invalid arguments for each method.
 */

import java.util.Arrays;
import junit.framework.TestCase;

/**
 * Reference tests for PA5.
 * 
 * @author R.Grove
 * @author C.Mayfield
 * @author N.Harris
 * @version 0.2 2012Nov08
 */
public class ReferenceTests extends TestCase {
    
    public static void testGeneratePicks() {
        int[] expect;
        int[] actual;
        
        expect = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        actual = Lottery.generatePicks(10, 1, 10, 1);
        assertTrue("error in generatePicks (1 to 10)",
                   Arrays.equals(expect, actual));
        
        expect = new int[] { 41, 68, 69, 109, 351, 373, 390, 607, 720, 848 };
        actual = Lottery.generatePicks(10, 1, 1000, 2);
        assertTrue("error in generatePicks (1 to 1000)",
                   validatePicks(1, 1000, actual));
//                 Arrays.equals(expect, actual));
        
        expect = new int[] { 104, 108, 121, 131, 136, 146, 148, 163, 170, 188 };
        actual = Lottery.generatePicks(10, 100, 200, 3);
        assertTrue("error in generatePicks (100 to 200)",
                   validatePicks(100, 200, actual));
//                 Arrays.equals(expect, actual));
        
        actual = Lottery.generatePicks(2, 1, 10, 123546);
        assertTrue("error in generatePicks (size too small)",
                   actual == null);
        
        actual = Lottery.generatePicks(7, 1, 6, 123546);
        assertTrue("error in generatePicks (size bigger than range)",
                   actual == null);
    }
    
    /*
     * Check to see if the picks are in range, sorted, and unique.
     */
    private static boolean validatePicks(int low, int high, int[] picks) {
        for (int i=0; i<picks.length; i++) {
            // validate range
            if (picks[i] < low || picks[i] > high) {
                return false;
            }
            
            // validate order && uniqueness
            if (i < picks.length - 1 && picks[i] >= picks[i+1]) {
                return false;
            }      
        }
        return true;
    }
    
    public static void testCheckUserNumbers() {
        int[] a1 = { 1, 2, 3, 4, 5 };
        int[] a2 = { 5, 4, 3, 2, 1 };
        assertEquals("error in checkUserNumbers (all overlap)",
                     5, Lottery.checkUserNumbers(a1, a2));
        
        int[] a3 = { 4, 5, 6, 7, 8 };
        assertEquals("error in checkUserNumbers (some overlap)",
                     2, Lottery.checkUserNumbers(a2, a3));
        
        int[] a4 = { 10, 11, 12, 13, 14 };
        assertEquals("error in checkUserNumbers (none overlap)",
                     0, Lottery.checkUserNumbers(a1, a4));
        
        int[] a5 = { 1, 2, 19, 21 };
        assertEquals("error in checkUserNumbers (wrong sizes)",
                     -1, Lottery.checkUserNumbers(a1, a5));
        
        assertEquals("error in checkUserNumbers (null values)",
                     -1, Lottery.checkUserNumbers(null, null));
    }
    
    public static void testSortArray() {
        int[] a0 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        int[] a1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        int[] a2 = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
        int[] s1;
        int[] s2;
        
        s1 = Lottery.sortArray(a1);
        assertTrue("error in sortArray (wrong answer 1)", Arrays.equals(s1, a0));
        assertTrue("error in sortArray (same object 1)", s1 != a1);
        
        s2 = Lottery.sortArray(a2);
        assertTrue("error in sortArray (wrong answer 2)", Arrays.equals(s2, a0));
        assertTrue("error in sortArray (same object 2)", s2 != a2);
        
        s1 = Lottery.sortArray(null);
        assertTrue("error in sortArray (null value)", s1 == null);
    }
    
    public static void testGeneratePrizes() {
        int[] expect;
        int[] actual;
        
        expect = new int[] { 0, 0, 0, 0, 0, 0, 0, 1, 5, 19, 75 };
        actual = Lottery.generatePrizes(10, 100);
        assertTrue("error in generatePrizes (10, 100)",
                   Arrays.equals(expect, actual));
        
        expect = new int[] { 0, 0, 0, 62, 188, 750 };
        actual = Lottery.generatePrizes(5, 1000);
        assertTrue("error in generatePrizes (5, ...)",
                   Arrays.equals(expect, actual));
        
        expect = new int[] { 0, 0, 0, 1000};
        actual = Lottery.generatePrizes(3, 1000);
        assertTrue("error in generatePrizes (3, 1000)",
                   Arrays.equals(expect, actual));
        
        actual = Lottery.generatePrizes(1Big Boxes "lengthxwidthxdepth": n
Medium Boxes "lengthxwidthxdepth": n
Small Boxes "lengthxwidthxdepth": n , 1000);
        assertTrue("error in generatePrizes (1, 1000)",
                   actual == null);
        
        actual = Lottery.generatePrizes(5, -500);
        assertTrue("error in generatePrizes (5, -500)",
                   actual == null);
    }
    
}
