import org.junit.Test;
import static org.junit.Assert.*;

public class LifeTest {
    
    @Test
    public void createNewCell() {
        
        // Arrange: drei lebende Zellen
        Life l = new Life();
        l.setAlive(0, 0);
        l.setAlive(0, 1);
        l.setAlive(0, 2);

        // Act: Berechnung der Folgegeneration
        ILife nextGen = l.nextGeneration();

        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
        assertTrue(nextGen.isAlive(1, 1));
    }


    @Test
    public void destroyLonelyCell() {
        // Zellen, die weniger als zwei Nachbarn haben, müssen sterben (Einsamkeit).



        // ----- ANMERKUNG -----

        // Nach dem Schreiben und Ausführen dieses Tests, habe ich den bisher bestehenden Code so verstanden,
        // dass die Zellen ja mit jeder neuen Generation standardmäßig als 'tot' initialisiert werden,
        // solange man nicht ausdrücklich zuvor sagte, die Zelle soll leben.
        // Sprich lebende Zellen aus der alten Generation werden zunächst nicht in die Folgegeneration vererbt und
        // dort dann geschaut, ob diese noch sterben müssen.
        //
        // Demnach bin ich an diesem Punkt nun etwas verwirrt um die generelle Notwendigkeit einer setDead()-Methode,
        // werde sie sowie die übrigen Tests und Funktionen aber dennoch implementieren. Jedoch ist es möglich,
        // dass ich nun die TDD-Methodik weniger gezielt anwenden werde. Grund hierfür ist, dass ich es auch als
        // sinnfrei empfinde, den Code gezielt entsprechend zu manipulieren, nur damit der Test erzwungenermaßen failed.
        //
        // Zudem ist nach der Ausarbeitung, also dem Refactoring des Codes (jedenfalls war das meine Intention dabei)
        // anhand des ersten Testfalls ja nun bereits sämtliche nötige Logik implementiert.
        //
        // Also ist mein Ziel nun wie gesagt, dass ich nach bestem Wissen und Gewissen alles weiterhin schrittweise
        // implementieren werde, aber es möglich ist, dass mMn redundante Zwischenschritte fehlen könnten.



        // Arrange: lebende Zelle (1,1) hat weniger als zwei Nachbarn und sollte sterben.
        Life l = new Life();
        l.setAlive(1, 1);
        l.setAlive(0, 0);

        // Act: Berechnung der Folgegeneration
        ILife nextGen = l.nextGeneration();

        // Assert: Zelle (1,1) sollte tot sein
        assertFalse(nextGen.isAlive(1, 1));


        // Was für destroyCell eigentlich, wozu setDead generell??? Die Zelle wird doch sowieso in der nextGen mit
        // false initalisiert, solange sie nicht explizit als true (mittels setAlive) initialisiert werden soll.
        // Deshalb wird der Test ja sogar jetzt ohne setDead-Implementierung grün.
        //
        // Ich muss doch nie eine Zelle aktiv mit setDead destroyen, wenn sie in der Folgegeneration sowieso immer
        // zu Anfang tot ist, solange ich sie nicht aktiv belebe?
    }


    @Test
    public void keepAliveCell() {
        // Zellen mit zwei oder drei Nachbarn bleiben am Leben.
    }


    @Test
    public void destroyCrowdedCell() {
        // Zellen mit mehr als drei Nachbarn sterben (Überbevölkerung).
    }


}