84 lines
3.1 KiB
Java
84 lines
3.1 KiB
Java
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).
|
|
}
|
|
|
|
|
|
}
|