Init

.gitignore

+.vscode/settings.json
+.gitignore

GameOfLifeTDD.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="jars" level="project" />
+  </component>
+</module>

README.md

+# Programmieren 3
+
+## Assignment "Game Of Life"  
+
+### Einführung
+
+#### Game of Life
+
+Ihre Aufgabe ist es, eine Klasse <code>Life</code> zu implementieren,
+die das *Game of Life* simuliert. Beim *Game of Life* 
+werden Zellen in einem zweidimensionelen Raster angeordnet. 
+An jedem Rasterpunkt kann entweder eine lebende Zelle oder ein
+Leerraum positioniert werden.
+
+Für das Entstehen, Überleben oder Absterben einer Zelle
+ist die Anzahl der unmittelbaren Nachbarn entscheidend.
+Jeder Rasterpunkt hat 8 benachbarte Rasterpunkte 
+(links, rechts, oben, unten, oben links, oben rechts, unten links, unten rechts).
+Für die Berechnung der nachfolgenden Generation sind auf die
+aktuelle Generation folgende Regeln anzuwenden:
+
+- Eine neue Zelle an einem bisher unbelebten Rasterpunkt entsteht,
+  wenn genau drei benachbarte Rasterpunkte mit lebenden Zellen 
+  besetzt sind.
+
+- Lebende Zellen mit weniger als zwei lebenden Nachbarn sterben in der Folgegeneration an Einsamkeit.
+
+- Eine lebende Zelle mit zwei oder drei lebenden Nachbarn bleibt in der Folgegeneration am Leben.
+
+- Lebende Zellen mit mehr als drei lebenden Nachbarn sterben in der Folgegeneration an Überbevölkerung.
+
+
+#### Vorgaben
+
+Im Assignment werden Ihnen drei Code-Dateien vorgegeben:
+
+- <code>Life</code> soll später den Produktivcode enthalten.
+- <code>LifeTest</code> soll für den Testcode benutzt werden.
+- <code>ILife</code> ist ein Interface, das von der <code>Life</code>-Klasse
+  implementiert werden soll.
+
+### Aufgabenstellung
+
+Implementieren Sie die Klasse <code>Life</code> unter Nutzung der TDD-Vorgehensweise.
+Erstellen Sie für die oben genannten Regeln jeweils mindestens einen Testfall (für
+die erste Regel wurde bereits ein Testfall mitgeliefert).
+
+

src/ILife.java

+public interface ILife {
+
+    // Methoden zum Setzen der Ausgangssituation
+    public void nukeAll();
+    public void setAlive(int x, int y);
+    public void setDead(int x, int y);
+
+    // Methoden zum Abfragen der aktuellen Situation
+    public boolean isAlive(int x, int y);
+
+    // Methoden zum Fortschreiben der Generationen
+    public ILife nextGeneration();
+
+}

src/Life.java

+public class Life implements ILife {
+  
+  public static void main(String[] args) {
+    Life l = new Life(new String[] {  "     ",
+                                      "     ",
+                                      " *** ",
+                                      "     ",
+                                      "     " });
+    l = (Life) l.nextGeneration();
+  }
+
+
+  public Life() {
+    nukeAll();
+  }
+
+  public Life(String[] setup) {
+    this();
+    for (int y = 0; y < setup.length; y++)
+      for (int x = 0; x < setup[y].length(); x++)
+        if (setup[y].charAt(x) != ' ')
+          setAlive(x, y);
+  }
+
+
+  @Override
+  public void nukeAll() {
+    // TODO Auto-generated method stub
+
+  }
+
+  @Override
+  public void setAlive(int x, int y) {
+    // TODO Auto-generated method stub
+
+  }
+
+  @Override
+  public void setDead(int x, int y) {
+    // TODO Auto-generated method stub
+
+  }
+
+  @Override
+  public boolean isAlive(int x, int y) {
+    // TODO Auto-generated method stub
+    return false;
+  }
+
+  @Override
+  public ILife nextGeneration() {
+    // TODO Auto-generated method stub
+    return null;
+  }
+}

test/LifeTest.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() {
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+    }
+
+
+}