import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Random;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 * Inoffzielle Testklasse zur Hausaufgabe 5 von Blatt 7 des PGdP im WS 2016/17.
 * Keine Garantie für Richtigkeit.
 * An dieses Klasse nimmt man sich bitte kein Beispiel (sehr schlechter 
 * Code-Stil, wirklich nur zum Testen gut -> danach Trash).
 * 
 * @author Stefan Berktold
 * @version 06.12.2016
 */
public class HeadListTest {
    
    final Random R = new Random();

    /**
     * Test of add method, of class HeadList.
     */
    @Test
    public void testAdd() {
        final int AMOUNT_TESTCASES = 10;
        final int MAX_SIZE = 50000; // reduzieren, falls langsame Implementierung
        
        System.out.print("add... ");
        
        for (int i = 1; i <= AMOUNT_TESTCASES; i++) { 
            HeadList test = new HeadList();
            List<Integer> correct = new LinkedList();
            
            assertTrue("Head der Liste war anfangs nicht null sondern " + 
                    test.head + " (Class: " + (test.head != null ? 
                    test.head.getClass() : null) + ")", test.head == null);
            
            int length = R.nextInt(MAX_SIZE);
            for (int j = 0; j < length; j++) {
                int add = R.nextInt(Integer.MAX_VALUE);
                test.add(add);
                correct.add(add);
            }
            
            int pos = 0;
            ListIterator it = correct.listIterator();
            HeadList.Entry currentEntry = test.head;
            while (it.hasNext()) {
                int c = (Integer) it.next();
                assertTrue("Element an Position " + pos + " war " + currentEntry.elem
                        + ". Erwartet: " + c, (c == currentEntry.elem));
                currentEntry = currentEntry.next;
                pos++;
            }
            
            assertTrue("Die tatsächliche Listenlänge (" + pos + ") entspricht nicht"
                    + " der erwarteten Länge " + length, pos == length);
        }
        
        System.out.println("Finished.");
    }

    /**
     * Test of remove method, of class HeadList.
     */
    @Test
    public void testRemove() {
        final int AMOUNT_TESTCASES = 1000;
        final int MAX_SIZE = 100; 
        
        System.out.println("remove:");
        
        System.out.print("- nur vorne entfernen... ");
        for (int i = 1; i <= AMOUNT_TESTCASES; i++) { 
            HeadList test = new HeadList();
            //System.out.println("Vor: " +test.toString());
            List<Integer> correct = new ArrayList();
            
            int length = R.nextInt(MAX_SIZE);
            for (int j = 0; j < length; j++) {
                int add = R.nextInt(Integer.MAX_VALUE);
                test.add(add);
                correct.add(add);
            }
            
            int pos = 1;
            for (int j = 0; j < length; j++) {
                int c = correct.remove(0);
                int e = test.remove(0);
                assertTrue("Der " + pos + ". von " + length + " Versuchen, das vorderste "
                        + " Element (head) zu entfernen lieferte statt " + c
                        + " " + (e == Integer.MIN_VALUE ? "MIN_VALUE" : e)
                        + ".", c == e);
                pos++;
                //System.out.println("Nach " + j + ": " +test.toString());
                
                // Liste komplett auf Korrektheit prüfen:
                int pos1 = 0;
                HeadList.Entry currentEntry = test.head;
                for (int k = 0; k < correct.size(); k++) {
                    int c1 = correct.get(k);
                    assertTrue("Der " + pos + ". Löschvorgang des Elements am "
                            + "Index 0 (Head) lieferte zwar das"
                            + " richtige Element (" + e + ") zurück, allerdings"
                            + " war die Liste danach nicht korrekt verkettet."
                            + " Die Überprüfung schlug beim Element am Index "
                            + pos1 + " fehl, nachdem " + c1 + " erwartet wurde, "
                            + "während " + currentEntry.elem + " gefunden wurde.",
                            (c1 == currentEntry.elem));
                    assertTrue("Nach dem " + pos + ". Löschvorgang des Elements am "
                            + "Index 0 (Head) stimmten die Referenzen auf Head nicht. "
                            + "Eventuell vergessen zu aktualisieren, nachdem "
                            + "Head ja gelöscht wurde?", test.head == currentEntry.first);
                    currentEntry = currentEntry.next;
                    pos1++;
                }
            }
            
            assertTrue("Das Entfernen konnte trotz einer Listenlänge von " + 
                    length + " " + (pos-1) + "x durchgeführt werden!?",
                    pos-1 == length);
            assertTrue("Nach dem Löschen aller Elemente ist der Head trotzdem"
                    + " nicht null sondern " + (test.head != null ? test.head.elem : null),
                    test.head==null);
            int res = test.remove(0);
            assertTrue("Nach dem Löschen aller Elemente war der Head zwar null,"
                    + " allerdings lieferte remove(0) trotzdem " + res + ". "
                    + "Erwartet wurde MIN_VALUE (" + Integer.MIN_VALUE + ").", 
                    res == Integer.MIN_VALUE);
            assertTrue("Fehler im Test? Die Listenlänge nach dem Entfernen aller "
                    + "Elemente betrug nicht 0!?", correct.isEmpty());
        }
        System.out.println("Finished.");
        
        System.out.print("- durcheinander entfernen... ");
        for (int i = 1; i <= AMOUNT_TESTCASES; i++) { 
            HeadList test = new HeadList();
            List<Integer> correct = new ArrayList();
            
            int length = R.nextInt(MAX_SIZE);
            for (int j = 0; j < length; j++) {
                int add = R.nextInt(Integer.MAX_VALUE);
                test.add(add);
                correct.add(add);
            }
            
            int pos = 1;
            int remainingLength = length;
            while (remainingLength > 0) {
                int remove = R.nextInt(remainingLength);
                int c = correct.remove(remove);
                int e = test.remove(remove);
                
                assertTrue("Der Versuch, das Element am Index " + remove + 
                        " zu entfernen, lieferte statt " + c + " das Element " +
                        e + ". Durchlauf: " + (pos == 1 ? "Erster" : pos) + 
                        ". Verbleibende Listenlänge: " + remainingLength + 
                        " von " + length + ".", c == e);
                
                // Liste komplett auf Korrektheit prüfen:
                int pos1 = 0;
                HeadList.Entry currentEntry = test.head;
                for (int k = 0; k < correct.size(); k++) {
                    int c1 = correct.get(k);
                    assertTrue("Der " + pos + ". Löschvorgang lieferte zwar das"
                            + " richtige Element (" + e + ") zurück, allerdings"
                            + " war die Liste danach nicht korrekt verkettet."
                            + " Die Überprüfung schlug beim Element am Index "
                            + pos1 + " fehl, nachdem " + c1 + " erwartet wurde, "
                            + "während " + currentEntry.elem + " gefunden wurde.",
                            (c1 == currentEntry.elem));
                    currentEntry = currentEntry.next;
                    pos1++;
                }
            
                pos++;
                remainingLength--;
            }
            
            assertTrue("Das Entfernen konnte trotz einer Listenlänge von " + 
                    length + " " + (pos-1) + "x durchgeführt werden!?",
                    pos-1 == length);
            assertTrue("Nach dem Löschen aller Elemente ist der Head trotzdem"
                    + " nicht null sondern " + (test.head != null ? test.head.elem : null),
                    test.head==null);
            int remove = (length == 0) ? 0 : R.nextInt(length);
            int res = test.remove(remove);
            assertTrue("Nach dem Löschen aller Elemente war der Head zwar null,"
                    + " allerdings lieferte remove(" + remove + ") trotzdem " + 
                    res + ". " + "Erwartet wurde MIN_VALUE (" + Integer.MIN_VALUE + ").", 
                    res == Integer.MIN_VALUE);
            assertTrue("Fehler im Test? Die Listenlänge nach dem Entfernen aller "
                    + "Elemente betrug nicht 0!?", correct.isEmpty());
        }
        System.out.println("Finished.");
        
        System.out.print("- aus leerer Liste... ");
        HeadList test = new HeadList();
        int remove;
        remove = test.remove(1);
        assertTrue("Man konnte aus der leeren Liste entfernen. Element mit Index "
                + "1 wurde angeblich entfernt und hatte den Wert " + remove +
                ". Erwartete Rückgabe: " + Integer.MIN_VALUE,
                remove == Integer.MIN_VALUE);
        remove = test.remove(0);
        assertTrue("Man konnte aus der leeren Liste entfernen. Element mit Index "
                + "0 wurde angeblich entfernt und hatte den Wert " + remove +
                ". Erwartete Rückgabe: " + Integer.MIN_VALUE,
                remove == Integer.MIN_VALUE);
        System.out.println("Finished.");
    }

    /**
     * Test of reverse method, of class HeadList.
     */
    @Test
    public void testReverse() {
        final int AMOUNT_TESTCASES = 1000;
        final int MAX_SIZE = 100; 
        
        System.out.println("reverse:");
        
        System.out.print("- zufällige Listen... ");
        for (int i = 1; i <= AMOUNT_TESTCASES; i++) { 
            HeadList test = new HeadList();
            String pre = test.toString();
            List<Integer> correct = new LinkedList();
            
            int length = R.nextInt(MAX_SIZE);
            for (int j = 0; j < length; j++) {
                int add = R.nextInt(Integer.MAX_VALUE);
                test.add(add);
                correct.add(add);
            }
            
            //System.out.println("Vor: " +test.toString());
            Collections.reverse(correct);
            test.reverse();
            //System.out.println("Nach: " +test.toString());
            
            ListIterator it = correct.listIterator();
            HeadList.Entry e = test.head;
            int id = 0;
            while (it.hasNext()) {
                int c = (Integer) it.next();
                assertTrue("Reverse hat nicht funktioniert. Nach dem Reversen "
                        + "wurde an Index " + id + " statt " + c + " " + e.elem
                        + " gefunden.\nListe vor dem reverse: " + pre + "\n"
                        + "Liste nach dem reverse: " + test.toString(), c == e.elem);
                e = e.next;
                id++;
            }
        }
        System.out.println("Finished.");
        
        System.out.print("- leere Liste... ");
        HeadList test = new HeadList();
        assertTrue("Leere Liste anfangs nicht leer? Head sollte null sein!", test.head == null);
        test.reverse();
        assertTrue("Ergebnis von reverse einer leeren Liste ungleich leere Liste", test.head == null);
        System.out.println("Finished.");
    }
}