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 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 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 ++ ;
        }
    }

   

    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};

    
}