import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.util.Arrays;

/**
 * The test class ArrayExperimenteTest.
 *
 * @author  Urs Lautebach
 * @version 2017-10
 */
public class ArrayExperimenteTest
{
    /**
     * Sets up the test fixture.
     *
     * Called before every test case method.
     */
    @Before
    public void setUp()
    {
    }

    /**
     * Tears down the test fixture.
     *
     * Called after every test case method.
     */
    @After
    public void tearDown()
    {
    }

    @Test
    public void testistEnthalten()
    {
        int[] testArray = new int[] {1, -43, 1000, 1000, 3, 4, 13, 1000, 70, -41};
        assertTrue(ArrayExperimente.istEnthalten(1000, testArray));
        assertTrue(ArrayExperimente.istEnthalten(-41, testArray));
        assertTrue(ArrayExperimente.istEnthalten(1, testArray));
        assertFalse(ArrayExperimente.istEnthalten(77, testArray));

        testArray = new int[] {66};
        assertTrue(ArrayExperimente.istEnthalten(66, testArray));
        assertFalse(ArrayExperimente.istEnthalten(77, testArray));

        testArray = new int[] {};
        assertFalse(ArrayExperimente.istEnthalten(77, testArray));
    }

    @Test
    public void testindexVon()
    {
        int[] testArray = new int[] {1, -43, 1000, 1000, 3, 4, 13, 1000, 70, -41};
        assertEquals(0, ArrayExperimente.indexVon(1, testArray));
        assertEquals(1, ArrayExperimente.indexVon(-43, testArray));
        assertEquals(9, ArrayExperimente.indexVon(-41, testArray));
        assertEquals(-1, ArrayExperimente.indexVon(1231, testArray));

        testArray = new int[] {66};
        assertEquals(-1, ArrayExperimente.indexVon(1231, testArray));
        assertEquals(0, ArrayExperimente.indexVon(66, testArray));

        testArray = new int[] {};
        assertEquals(-1, ArrayExperimente.indexVon(1231, testArray));
    }

    @Test
    public void testindexVonBinaer()
    {
        assertEquals(-1, ArrayExperimente.indexVonBinaer(4, null));
        int[] testArray = new int[] {};
        assertEquals(-1, ArrayExperimente.indexVonBinaer(4, testArray));

        testArray = new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        for(int i : testArray) {
            assertEquals(i, ArrayExperimente.indexVonBinaer(i, testArray));
        }
        assertEquals(-1, ArrayExperimente.indexVonBinaer(17, testArray));

    }

    @Test
    public void testmaxWert()
    {
        int[] testArray = new int[] {1, -43, 1000, 1000, 3, 4, 13, 1000, 70, -41};
        assertEquals(1000, ArrayExperimente.maxWert(testArray));

        testArray = new int[] {0, -43, -41};
        assertEquals(0, ArrayExperimente.maxWert(testArray));

        testArray = new int[] {-43, -41};
        assertEquals(-41, ArrayExperimente.maxWert(testArray));

        testArray = new int[] {66};
        assertEquals(66, ArrayExperimente.maxWert(testArray));
    }

    @Test
    public void testmaxIndex()
    {
        int[] testArray = new int[] {1, -43, 1000, 3, 4, 13, 70, -41};
        assertEquals(2, ArrayExperimente.maxIndex(testArray));

        testArray = new int[] {1, -43, 1000, 3, 4, 13, 70, -41, 5367};
        assertEquals(8, ArrayExperimente.maxIndex(testArray));

        testArray = new int[] {0, -43, -41};
        assertEquals(0, ArrayExperimente.maxIndex(testArray));

        testArray = new int[] {-43, -41};
        assertEquals(1, ArrayExperimente.maxIndex(testArray));

        testArray = new int[] {-41};
        assertEquals(0, ArrayExperimente.maxIndex(testArray));
    }

    @Test
    public void testquersumme()
    {
        int[] testArray = new int[] {1, -43, 3, 4, 13, 70, -41};
        assertEquals(7, ArrayExperimente.querSumme(testArray));

        testArray = new int[] {0, -43, -41};
        assertEquals(-84, ArrayExperimente.querSumme(testArray));

        // einelementiges Array:
        testArray = new int[] {51};
        assertEquals(51, ArrayExperimente.querSumme(testArray));
    }

    @Test
    public void testaddiereJeweilsD()
    {
        int[] arrayVorher = new int[] {1, -43, 3, 4, 13, 70, -41};
        int[] testArray   = new int[] {1, -43, 3, 4, 13, 70, -41};

        int dazu = 1;
        ArrayExperimente.addiereJeweilsD(testArray, dazu);

        int idx = 0;
        while(idx < testArray.length)
        {
            if( testArray[idx] != arrayVorher[idx] + dazu )
            {
                fail("Arrays unterscheiden sich an der Position " + idx + "!");
            }
            idx ++ ;
        }
    }

    @Test
    public void testvektorsumme()
    {
        int[] a   = new int[] { 1, -43, 3, 4, 13, 70, -41 };
        int[] b   = new int[] { 5, -4,  8, 4, 11, 7,    5 };
        int[] summe = ArrayExperimente.vektorsumme(a, b);
        assertNotNull(summe);

        int idx = 0;
        while(idx < a.length)
        {
            if( summe[idx] != a[idx] + b[idx] )
            {
                fail("Summe falsch an der Position " + idx + "!");
            }
            idx ++ ;
        }
    }

    @Test
    public void testarrayUmdrehen()
    {
        // Array mit ungerader Laenge:
        int[] drehmich = new int[] { 1, -43, 3, 4, 13, 70, -41 };
        int[] rumgedreht = ArrayExperimente.arrayUmdrehen(drehmich);
        assertEquals(drehmich.length, rumgedreht.length);

        int idx = 0;
        while(idx < drehmich.length) {
            if( rumgedreht[idx] != drehmich[ rumgedreht.length - 1 - idx ] ) {
                fail("Ergebnisarray falsch bei Index " + idx + "!");
            }
            idx ++ ;
        }

        // Array mit gerader Laenge:
        drehmich = new int[] { 1, -43, 3, 4, 70, -41 };
        rumgedreht = ArrayExperimente.arrayUmdrehen(drehmich);
        assertEquals(drehmich.length, rumgedreht.length);

        idx = 0;
        while(idx < drehmich.length) {
            if( rumgedreht[idx] != drehmich[ rumgedreht.length - 1 - idx ] ) {
                fail("Ergebnisarray falsch bei Index " + idx + "!");
            }
            idx ++ ;
        }

        // Array mit Laenge 1:
        drehmich = new int[] { 1 };
        rumgedreht = ArrayExperimente.arrayUmdrehen(drehmich);
        assertEquals(drehmich.length, rumgedreht.length);

        idx = 0;
        while(idx < drehmich.length) {
            if( rumgedreht[idx] != drehmich[ rumgedreht.length - 1 - idx ] ) {
                fail("Ergebnisarray falsch bei Index " + idx + "!");
            }
            idx ++ ;
        }
    }

    @Test
    public void testBubblesort()
    {
        int[][] zuSortierendeArrays = new int[][]
            {
                {  },
                { 1 },
                { 1, 2 },
                { 2, 1  },
                { 2, 1, 0 },
                { 1, 2, 3 },
                { 66, 66, 66 },
                { 34,853,8,3246,324,797434,72374,346,4,2,7,248,33,835,8 },
                { 8,3,8,3,9,3,5,2,65,1,6,2,78,27,8,37 },
                { -45,0,8,8,0,67,3,7,9,0,9,5,2,65,5,9,0,4,8,7,4,78,689 },
                { 4,7,435,87,657,234,6,56,9,347,86,80,5476,5,79,568,9067,53,23, },
                { 1,2,3,4,5,6,7,8,9 },
                { -1,-2,-3,-4,-5,-6,-7,-8,-9 },
            };
        for(int[] einArray : zuSortierendeArrays)
        {
            // mach eine Kopie vom zu sortierenden Array:
            int[] kopieVomArray = Arrays.copyOf(einArray, einArray.length);

            // mach noch Kopie davon...
            int[] arrayKorrektSortiert = Arrays.copyOf(einArray, einArray.length);
            // ... und sortiere sie mit einem Verfahren, das sicher korrekt ist:
            Arrays.sort(arrayKorrektSortiert);
            // sortiere die erste Kopie mit der zu testenden Implementierung:
            ArrayExperimente.bubbleSort(kopieVomArray);
            // stimmen die beiden sortierten genau ueberein?
            if(false == Arrays.equals(arrayKorrektSortiert, kopieVomArray))
                fail("Sortieren klappt nicht in Array " + Arrays.toString(einArray));
        }
    }

    @Test
    public void testmysort()
    {
        int[][] zuSortierendeArrays = new int[][]
            {
                {  },
                { 1 },
                { 1, 2 },
                { 2, 1  },
                { 2, 1, 0 },
                { 1, 2, 3 },
                { 66, 66, 66 },
                { 34,853,8,3246,324,797434,72374,346,4,2,7,248,33,835,8 },
                { 8,3,8,3,9,3,5,2,65,1,6,2,78,27,8,37 },
                { -45,0,8,8,0,67,3,7,9,0,9,5,2,65,5,9,0,4,8,7,4,78,689 },
                { 4,7,435,87,657,234,6,56,9,347,86,80,5476,5,79,568,9067,53,23, },
                { 1,2,3,4,5,6,7,8,9 },
                { -1,-2,-3,-4,-5,-6,-7,-8,-9 },
            };
        for(int[] einArray : zuSortierendeArrays)
        {
            // mach eine Kopie vom zu sortierenden Array:
            int[] kopieVomArray = Arrays.copyOf(einArray, einArray.length);

            // mach noch Kopie davon...
            int[] arrayKorrektSortiert = Arrays.copyOf(einArray, einArray.length);
            // ... und sortiere sie mit einem Verfahren, das sicher korrekt ist:
            Arrays.sort(arrayKorrektSortiert);
            // sortiere die erste Kopie mit der zu testenden Implementierung:
            ArrayExperimente.mySort(kopieVomArray);
            // stimmen die beiden sortierten genau ueberein?
            if(false == Arrays.equals(arrayKorrektSortiert, kopieVomArray))
                fail("Sortieren klappt nicht in Array " + Arrays.toString(einArray));
        }
    }
    private boolean[][] binaer =
        {
            { false, false, false, false, false, false, false, false } , /*    0      */
            { false, true , true , true , true , true , true , true  } , /*    127    */
            { false, false, false, false, false, true , true , true  } , /*    7      */
            { false, true , true , false, false, false, false, false } , /*    96     */
            { false, false, true , false, false, true , false, false } , /*    36     */
            { false, false, false, false, false, true , false, true  } , /*    5     */
            { false, false, false, false, false, true , false, false } , /*    4     */
            { false, false, false, true , false, false, false, true  } , /*    17     */
            { false, true , false, false, false, false, false, true  } , /*    65     */
            { false, false, false, false, false, false, false, true  } , /*    1     */

        };

    private byte[] dezimal = { 0, 127, 7, 96, 36, 5, 4, 17, 65, 1};

    @Test
    public void testbinaerNachDezimal()
    {
        if(binaer.length != dezimal.length)
            fail("Der Test braucht gleich viele Binaer- wie Dezimnaldarstellungen!");
        for(int i = 0; i < binaer.length; i ++) {
            byte ergebnis = ArrayExperimente.binaerNachDezimal(binaer[i]);

            if(dezimal[i] != ergebnis)
            {
                fail("Bei " + Arrays.toString(binaer[i]) + " muesste " + dezimal[i]
                    + " herauskommen statt " + ergebnis) ;
            }

        }
    }

    @Test
    public void testDezimalNachBinaerNull()
    {
        assertNull(ArrayExperimente.dezimalNachBinaer((byte)-7));

    }

    @Test
    public void testDezimalNachBinaer()
    {
        if(binaer.length != dezimal.length)
            fail("Der Test braucht gleich viele Binaer- wie Dezimnaldarstellungen!");
        for(int i = 0; i < binaer.length; i ++) {
            boolean[] ergebnis = ArrayExperimente.dezimalNachBinaer(dezimal[i]);

            if(false == Arrays.equals(binaer[i], ergebnis))
            {
                fail("Bei " + dezimal[i] + " muesste " + Arrays.toString(binaer[i])
                    + " herauskommen statt " + Arrays.toString(ergebnis) );
            }
        }
    }
}