diff --git a/README.md b/README.md
index 0a00073..d7651d3 100644
--- a/README.md
+++ b/README.md
@@ -35,7 +35,7 @@ aktuelle Generation folgende Regeln anzuwenden:
 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>LifeTestLinkerRand</code> soll für den Testcode benutzt werden.
 - <code>ILife</code> ist ein Interface, das von der <code>Life</code>-Klasse
   implementiert werden soll.
 
diff --git a/src/ILife.java b/src/ILife.java
index 28adbea..7535fa8 100644
--- a/src/ILife.java
+++ b/src/ILife.java
@@ -1,3 +1,4 @@
+
 public interface ILife {
 
     // Methoden zum Setzen der Ausgangssituation
@@ -7,8 +8,12 @@ public interface ILife {
 
     // Methoden zum Abfragen der aktuellen Situation
     public boolean isAlive(int x, int y);
+    public boolean isDead(int x, int y);
 
     // Methoden zum Fortschreiben der Generationen
     public ILife nextGeneration();
 
+    //Methode zum ausgeben der Welt
+    public void printWelt();
+
 }
diff --git a/src/Life.java b/src/Life.java
index 6c52a5d..40c7e15 100644
--- a/src/Life.java
+++ b/src/Life.java
@@ -1,5 +1,6 @@
 import java.util.Arrays;
 
+//Gruppe: @FrederikHagen, @DenushanJegatheeswaran, @NathanGebre-Michael, @Justus Görgens
 public class Life implements ILife {
 
   static String[] welt = new String[]{
@@ -25,7 +26,6 @@ public class Life implements ILife {
       for (int x = 0; x < setup[y].length(); x++)
         if (setup[y].charAt(x) != ' ')
           setAlive(x, y);
-    printWelt();
   }
 
   public void printWelt() {
@@ -66,6 +66,16 @@ public class Life implements ILife {
       return false;
   }
 
+  @Override
+  public boolean isDead(int x, int y) {
+    // TODO Auto-generated method stub
+
+    if (welt[y].charAt(x) == ' ')
+      return true;
+    else
+      return false;
+  }
+
   @Override
   public ILife nextGeneration() {
     // TODO Auto-generated method stub
@@ -88,11 +98,11 @@ public class Life implements ILife {
         //TODO fehler wenn x = 0
         if (nachbarn == 3) {
           if (x > 0 && x < welt[0].length() - 1) {
-            neueWelt[y] = neueWelt[y].substring(0, x - 1) + '*' + neueWelt[y].substring(x);
+            neueWelt[y] = neueWelt[y].substring(0, x) + '*' + neueWelt[y].substring(x + 1);
           } else if (x == 0) {
-            neueWelt[y] = '*' + neueWelt[y].substring(x);
+            neueWelt[y] = '*' + neueWelt[y].substring(x + 1);
           } else {
-            neueWelt[y] = neueWelt[y].substring(0, x - 1) + '*';
+            neueWelt[y] = neueWelt[y].substring(0, x) + '*';
           }
         }
 
@@ -100,15 +110,11 @@ public class Life implements ILife {
         //TODO fehler wenn x = 0
         if (nachbarn < 2 || nachbarn > 3) {
           if (x > 0 && x < welt[0].length() - 1) {
-            System.out.println(welt[0].length());
-            System.out.print(nachbarn);
-            System.out.print(", " + x);
-            System.out.println(", " + y);
-            neueWelt[y] = neueWelt[y].substring(0, x - 1) + ' ' + neueWelt[y].substring(x);
+            neueWelt[y] = neueWelt[y].substring(0, x) + ' ' + neueWelt[y].substring(x + 1);
           } else if (x == 0) {
-            neueWelt[y] = ' ' + neueWelt[y].substring(x);
+            neueWelt[y] = ' ' + neueWelt[y].substring(x + 1);
           } else {
-            neueWelt[y] = neueWelt[y].substring(0, x - 1) + ' ';
+            neueWelt[y] = neueWelt[y].substring(0, x) + ' ';
           }
         }
 
@@ -116,11 +122,11 @@ public class Life implements ILife {
         //TODO fehler wenn x = 0
         if ((nachbarn == 2) && (welt[y].charAt(x) == '*')) {
           if (x > 0 && x < welt[0].length() - 1) {
-            neueWelt[y] = neueWelt[y].substring(0, x - 1) + '*' + neueWelt[y].substring(x);
+            neueWelt[y] = neueWelt[y].substring(0, x) + '*' + neueWelt[y].substring(x + 1);
           } else if (x == 0) {
-            neueWelt[y] = '*' + neueWelt[y].substring(x);
+            neueWelt[y] = '*' + neueWelt[y].substring(x + 1);
           } else {
-            neueWelt[y] = neueWelt[y].substring(0, x - 1) + '*';
+            neueWelt[y] = neueWelt[y].substring(0, x) + '*';
           }
         }
       }
diff --git a/test/LifeTest.java b/test/LifeTest.java
deleted file mode 100644
index 3940e66..0000000
--- a/test/LifeTest.java
+++ /dev/null
@@ -1,38 +0,0 @@
-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() {
-    }
-
-
-}
diff --git a/test/LifeTestLinkerRand.java b/test/LifeTestLinkerRand.java
new file mode 100644
index 0000000..c475e16
--- /dev/null
+++ b/test/LifeTestLinkerRand.java
@@ -0,0 +1,82 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LifeTestLinkerRand {
+
+    @Test
+    public void createNewCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(0, 1);
+        l.setAlive(0, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(0, 1));
+    }
+
+
+    @Test
+    public void destroyLonelyCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 1);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt ohne Nachbarn sollte jetzt tot sein
+        assertTrue(nextGen.isDead(0, 1));
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(0, 1);
+        l.setAlive(0, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(0, 1));
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(1, 0);
+        l.setAlive(0, 1);
+        l.setAlive(0, 2);
+        l.setAlive(1, 1);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isDead(0, 1));
+        assertTrue(nextGen.isDead(1, 1));
+    }
+
+
+}
\ No newline at end of file
diff --git a/test/LifeTestMitte.java b/test/LifeTestMitte.java
new file mode 100644
index 0000000..3e5bd97
--- /dev/null
+++ b/test/LifeTestMitte.java
@@ -0,0 +1,83 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LifeTestMitte {
+
+    @Test
+    public void createNewCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(2, 0);
+        l.setAlive(2, 1);
+        l.setAlive(2, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(1, 1));
+        assertTrue(nextGen.isAlive(2, 1));
+        assertTrue(nextGen.isAlive(3, 1));
+    }
+
+    @Test
+    public void destroyLonelyCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(2, 1);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt ohne Nachbarn sollte jetzt tot sein
+        assertTrue(nextGen.isDead(2, 1));
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(2, 0);
+        l.setAlive(2, 1);
+        l.setAlive(2, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(2, 1));
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(2, 0);
+        l.setAlive(1, 0);
+        l.setAlive(2, 1);
+        l.setAlive(2, 2);
+        l.setAlive(1, 1);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isDead(2, 1));
+        assertTrue(nextGen.isDead(1, 1));
+    }
+
+
+}
diff --git a/test/LifeTestObererRand.java b/test/LifeTestObererRand.java
new file mode 100644
index 0000000..92cf69d
--- /dev/null
+++ b/test/LifeTestObererRand.java
@@ -0,0 +1,82 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LifeTestObererRand {
+
+    @Test
+    public void createNewCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(1, 0);
+        l.setAlive(2, 0);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(1, 0));
+    }
+
+
+    @Test
+    public void destroyLonelyCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(1, 0);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt ohne Nachbarn sollte jetzt tot sein
+        assertTrue(nextGen.isDead(1, 0));
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(1, 0);
+        l.setAlive(2, 0);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(1, 0));
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(0, 1);
+        l.setAlive(1, 0);
+        l.setAlive(2, 0);
+        l.setAlive(1, 1);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isDead(1, 0));
+        assertTrue(nextGen.isDead(1, 1));
+    }
+
+
+}
diff --git a/test/LifeTestRechterRand.java b/test/LifeTestRechterRand.java
new file mode 100644
index 0000000..84f13ff
--- /dev/null
+++ b/test/LifeTestRechterRand.java
@@ -0,0 +1,81 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LifeTestRechterRand {
+
+    @Test
+    public void createNewCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(4, 0);
+        l.setAlive(4, 1);
+        l.setAlive(4, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(4, 1));
+    }
+
+    @Test
+    public void destroyLonelyCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(4, 1);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt ohne Nachbarn sollte jetzt tot sein
+        assertTrue(nextGen.isDead(4, 1));
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(4, 0);
+        l.setAlive(4, 1);
+        l.setAlive(4, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(4, 1));
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(4, 0);
+        l.setAlive(3, 0);
+        l.setAlive(4, 1);
+        l.setAlive(4, 2);
+        l.setAlive(3, 1);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isDead(4, 1));
+        assertTrue(nextGen.isDead(3, 1));
+    }
+
+
+}
diff --git a/test/LifeTestUntererRand.java b/test/LifeTestUntererRand.java
new file mode 100644
index 0000000..c5b72cb
--- /dev/null
+++ b/test/LifeTestUntererRand.java
@@ -0,0 +1,82 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LifeTestUntererRand {
+
+    @Test
+    public void createNewCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 4);
+        l.setAlive(1, 4);
+        l.setAlive(2, 4);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(1, 4));
+    }
+
+    @Test
+    public void destroyLonelyCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(1, 4);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt ohne Nachbarn sollte jetzt tot sein
+        assertTrue(nextGen.isDead(1, 4));
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 4);
+        l.setAlive(1, 4);
+        l.setAlive(2, 4);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(1, 4));
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 4);
+        l.setAlive(0, 3);
+        l.setAlive(1, 4);
+        l.setAlive(2, 4);
+        l.setAlive(1, 3);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isDead(1, 4));
+        assertTrue(nextGen.isDead(1, 3));
+    }
+
+
+}
+