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
 * überarbeitet Ho, 24
 * @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.summe(testArray));

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

        // einelementiges Array:
        testArray = new int[] {51};
        assertEquals(51, ArrayExperimente.summe(testArray));
    }
    
    @Test
    public void testaddiereJeweilsEins()
    {
        int[] test = new int[] {1, -43, 3, 4, 13, 70, -41};
        int[] ergebnis = new int[] {2, -42, 4, 5, 14, 71, -40};

        ArrayExperimente.addiereJeweilsEins(test);
        
        assertArrayEquals(ergebnis, test);

    }
    
    @Test
    public void testaddiereJeweilsD()
    {
        int[] test = new int[] {1, -43, 3, 4, 13, 70};
        int d = 5;
        int[] ergebnis   = new int[] {6, -38, 8, 9, 18, 75};

        
        ArrayExperimente.addiereJeweilsD(test, d);

        assertArrayEquals(ergebnis, test);
    }



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

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

        // Array mit Laenge 1:
        test = new int[] { 1 };
        ergebnis = new int[] {1};
        umgedreht = ArrayExperimente.arrayUmdrehen(test);
        
        assertEquals(ergebnis.length, umgedreht.length);
        assertArrayEquals(ergebnis, umgedreht);
    }
    
    @Test
    public void testarrayUmdrehenInPlace()
    {
        // Array mit ungerader Laenge:
        int[] test = new int[] { 1, -43, 3, 4, 13, 70, -41 };
        ArrayExperimente.arrayUmdrehenInPlace(test); //test umdrehen
        int[] ergebnis = new int[] { -41, 70, 13, 4, 3, -43, 1 };
        
        assertEquals(ergebnis.length, test.length);
        assertArrayEquals(ergebnis, test);

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

        // Array mit Laenge 1:
        test = new int[] { 1 };
        ergebnis = new int[] {1};
        ArrayExperimente.arrayUmdrehenInPlace(test);
        
        assertEquals(ergebnis.length, test.length);
        assertArrayEquals(ergebnis, test);
    }

   
    
}