diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index aa991fc..fae0804 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/src/main/java/dev/oxoo2a/sim4da/Message.java b/src/main/java/dev/oxoo2a/sim4da/Message.java
index 0f5da9b..aaf164e 100644
--- a/src/main/java/dev/oxoo2a/sim4da/Message.java
+++ b/src/main/java/dev/oxoo2a/sim4da/Message.java
@@ -1,21 +1,42 @@
 package dev.oxoo2a.sim4da;
 
-import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.Map;
 
 import com.google.gson.Gson;
-import com.google.gson.reflect.TypeToken;
 
 public class Message {
 
+    private final String time;
+
     public Message () {
-        content = new HashMap<>();
+        this(new HashMap<>(), "");
     }
-
     protected Message ( HashMap<String,String> content ) {
+        this(content, "");
+    }
+    public Message(Time time){
+        this(new HashMap<>(), time.toString());
+    }
+    public Message(Message m, Time time){
+        this(m.content, time);
+    }
+    public Message(HashMap<String,String> content, Time time){
+        this(content, time.toString());
+    }
+    public Message(HashMap<String,String> content, String time){
         this.content = content;
+        this.time = time;
     }
+
+    public boolean hasTime(){
+        return !time.equals("");
+    }
+
+    public String getTime(){
+        return time;
+    }
+
     public Message add ( String key, String value ) {
         content.put(key,value);
         return this;
@@ -24,7 +45,6 @@ public Message add ( String key, String value ) {
     public Message add ( String key, int value ) {
         content.put(key,String.valueOf(value));
         return this;
-
     }
 
     public String query ( String key ) {
@@ -36,18 +56,17 @@ public Map<String,String> getMap () {
     }
 
     public String toJson () {
-        return serialize(content);
+        return serialize(this);
     }
 
     public static Message fromJson ( String s ) {
-        Type contentType = new TypeToken<HashMap<String,String>>() {}.getType();
-        return new Message(serializer.fromJson(s,contentType));
+        return serializer.fromJson(s, Message.class);
     }
 
-    private static synchronized String serialize ( Map<String,String> content ) {
-        return serializer.toJson(content); // Not sure about thread safety of Gson
+    private static synchronized String serialize ( Message m ) {
+        return serializer.toJson(m); // Not sure about thread safety of Gson
     }
 
-    private final HashMap<String,String> content;
-    private static final Gson serializer = new Gson();
+    protected final HashMap<String,String> content;
+    protected static final Gson serializer = new Gson();
 }
diff --git a/src/main/java/dev/oxoo2a/sim4da/NodeWithTime.java b/src/main/java/dev/oxoo2a/sim4da/NodeWithTime.java
new file mode 100644
index 0000000..bcf9ab4
--- /dev/null
+++ b/src/main/java/dev/oxoo2a/sim4da/NodeWithTime.java
@@ -0,0 +1,63 @@
+package dev.oxoo2a.sim4da;
+
+/***
+ * Node in the network that has a logic clock
+ * @author Tessa Steinigke
+ */
+public abstract class NodeWithTime extends Node {
+
+    protected final Time time; // manages the time according to the rules in the class of the logic clock
+    private final boolean logTime;
+
+    public NodeWithTime(int my_id, Time time) {
+        this(my_id, time, false);
+    }
+    public NodeWithTime(int my_id, Time time, boolean logTime) {
+        super(my_id);
+        this.time = time;
+        this.logTime = logTime;
+    }
+
+    protected void sendUnicast ( int receiver_id, String m ) {
+        time.incrementMyTime();
+        emit("Warning: Can not update time in message!");
+        if(logTime) emit("%d: perform Unicast at %s",myId,time.toString());
+        super.sendUnicast(receiver_id, m); // WARNING: can not update time in message
+    }
+
+    protected void sendUnicast ( int receiver_id, Message m ) {
+        time.incrementMyTime();
+        if(logTime) emit("%d: perform Unicast at %s",myId,time.toString());
+        super.sendUnicast(receiver_id, new Message(m, time));
+    }
+
+    protected void sendBroadcast ( String m ) {
+        time.incrementMyTime();
+        emit("Warning: Can not update time in message!");
+        if(logTime) emit("%d: perform Broadcast at %s",myId,time.toString());
+        super.sendBroadcast(m); // WARNING: can not update time in message
+    }
+
+    protected void sendBroadcast ( Message m ) {
+        time.incrementMyTime();
+        if(logTime) emit("%d: perform Broadcast at %s",myId,time.toString());
+        super.sendBroadcast(new Message(m, time));
+    }
+
+    protected Network.Message receive () {
+        Network.Message m_raw = super.receive();
+        if (m_raw != null) {
+            Message m = Message.fromJson(m_raw.payload);
+            // Update the time with the new time information given in the message
+            if(m.hasTime())
+                time.updateTime(m.getTime());
+
+            if(logTime) {
+                String m_type = m_raw.type == Network.MessageType.BROADCAST ? "Broadcast" : "Unicast";
+                emit("%d: receive %s at %s", myId, m_type,time.toString());
+            }
+        }
+        return m_raw;
+    }
+
+}
diff --git a/src/main/java/dev/oxoo2a/sim4da/Time.java b/src/main/java/dev/oxoo2a/sim4da/Time.java
new file mode 100644
index 0000000..095e4c3
--- /dev/null
+++ b/src/main/java/dev/oxoo2a/sim4da/Time.java
@@ -0,0 +1,29 @@
+package dev.oxoo2a.sim4da;
+
+public interface Time {
+    /***
+     * Increment the time of the local node
+     */
+    void incrementMyTime();
+
+    /***
+     * String representation of the time
+     * @return - time as string
+     */
+    String toString();
+
+    /***
+     * New time was received by a different node (sender).
+     * Now the time of the local node must be updated.
+     * @param time_sender - time of the sender node in the string representation
+     */
+    void updateTime(String time_sender);
+
+
+    /***
+     * New time was received by a different node (sender).
+     * Now the time of the local node must be updated.
+     * @param time_sender - time of the sender node
+     */
+    void updateTime(Time time_sender);
+}
diff --git a/src/main/java/dev/oxoo2a/sim4da/times/LamportTime.java b/src/main/java/dev/oxoo2a/sim4da/times/LamportTime.java
new file mode 100644
index 0000000..f9496c3
--- /dev/null
+++ b/src/main/java/dev/oxoo2a/sim4da/times/LamportTime.java
@@ -0,0 +1,46 @@
+package dev.oxoo2a.sim4da.times;
+
+import dev.oxoo2a.sim4da.Time;
+
+/***
+ * Implements the rules of the lamport time
+ */
+public class LamportTime implements Time {
+
+    private int time;
+
+    public LamportTime(){
+        time = 0;
+    }
+
+    @Override
+    public void incrementMyTime() {
+        time++;
+    }
+
+    @Override
+    public String toString() {
+        return time+"";
+    }
+
+    @Override
+    public void updateTime(String time_sender) {
+        int time_s_i = Integer.parseInt(time_sender);
+        // max function
+        if(time_s_i > time)
+            time = time_s_i;
+        // increment local time
+        incrementMyTime();
+    }
+
+    @Override
+    public void updateTime(Time time_sender) {
+        if(!( time_sender instanceof LamportTime))
+            throw new IllegalArgumentException("Wrong time format");
+        LamportTime l_time_sender = (LamportTime) time_sender;
+        if(l_time_sender.time > time)
+            time = l_time_sender.time;
+        // increment local time
+        incrementMyTime();
+    }
+}
diff --git a/src/main/java/dev/oxoo2a/sim4da/times/VectorTime.java b/src/main/java/dev/oxoo2a/sim4da/times/VectorTime.java
new file mode 100644
index 0000000..1fb049c
--- /dev/null
+++ b/src/main/java/dev/oxoo2a/sim4da/times/VectorTime.java
@@ -0,0 +1,58 @@
+package dev.oxoo2a.sim4da.times;
+
+import dev.oxoo2a.sim4da.Time;
+
+import java.util.Arrays;
+
+/***
+ * Implements the rules of the vector time
+ */
+public class VectorTime implements Time {
+
+    private int[] time;
+    private final int myId;
+
+    public VectorTime(int myId, int n_nodes){
+        time = new int[n_nodes];
+        for(int i = 0; i < n_nodes; i++){
+            time[i] = 0;
+        }
+        this.myId = myId;
+    }
+
+    @Override
+    public void incrementMyTime() {
+        time[myId]++;
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.toString(time);
+    }
+
+    @Override
+    public void updateTime(String time_sender) {
+        // increment local time
+        incrementMyTime();
+
+        time_sender = time_sender.substring(1, time_sender.length()-1);
+        String[] arr = time_sender.split(", ");
+        // max function
+        for(int i = 0; i < arr.length; i++){
+            int sender_i_int = Integer.parseInt(arr[i]);
+            if(sender_i_int > time[i])
+                time[i] = sender_i_int;
+        }
+    }
+
+    @Override
+    public void updateTime(Time time_sender) {
+        if(!( time_sender instanceof VectorTime))
+            throw new IllegalArgumentException("Wrong time format");
+        VectorTime v_time_sender = (VectorTime) time_sender;
+        for(int i = 0; i < time.length; i++){
+            if(v_time_sender.time[i] > time[i])
+                time[i] = v_time_sender.time[i];
+        }
+    }
+}
diff --git a/src/test/java/dev/oxoo2a/sim4da/NodeWithTimeTest.java b/src/test/java/dev/oxoo2a/sim4da/NodeWithTimeTest.java
new file mode 100644
index 0000000..e7bcb32
--- /dev/null
+++ b/src/test/java/dev/oxoo2a/sim4da/NodeWithTimeTest.java
@@ -0,0 +1,53 @@
+package dev.oxoo2a.sim4da;
+
+import dev.oxoo2a.sim4da.nodes.NodeWithTimeRandom;
+import dev.oxoo2a.sim4da.times.LamportTime;
+import dev.oxoo2a.sim4da.times.VectorTime;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+/***
+ * Test nodes with logic clocks
+ * @author Tessa Steinigke
+ */
+public class NodeWithTimeTest {
+
+    public enum TimeType { LAMPORT, VECTOR }
+
+    private static final int n_nodes = 3;
+
+    /***
+     * Same test for both clocks. Just the Time instances are different.
+     * @param type - Type of logic clock
+     */
+    private static void test(TimeType type){
+        Simulator s = Simulator.createDefaultSimulator(n_nodes);
+        for (int id=0; id<n_nodes; id++) {
+            Time time;
+            if(type == TimeType.LAMPORT)
+                time = new LamportTime();
+            else
+                time = new VectorTime(id, n_nodes);
+            NodeWithTime n = new NodeWithTimeRandom(id, time, n_nodes);
+            s.attachNode(id,n);
+        }
+        try {
+            s.runSimulation(2);
+        }
+        catch (InstantiationException ignored) {
+            fail("Not all nodes instantiated");
+        }
+    }
+
+    @Test
+    public void testLamportTime(){
+        test(TimeType.LAMPORT);
+    }
+
+    @Test
+    public void testVectorTime() {
+        test(TimeType.VECTOR);
+    }
+
+}
diff --git a/src/test/java/dev/oxoo2a/sim4da/SimulatorTest.java b/src/test/java/dev/oxoo2a/sim4da/SimulatorTest.java
index 7476fdc..c17a709 100644
--- a/src/test/java/dev/oxoo2a/sim4da/SimulatorTest.java
+++ b/src/test/java/dev/oxoo2a/sim4da/SimulatorTest.java
@@ -2,8 +2,7 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 
-import java.beans.Transient;
-
+import dev.oxoo2a.sim4da.nodes.BroadcastNode;
 import org.junit.jupiter.api.Test;
 
 public class SimulatorTest {
diff --git a/src/test/java/dev/oxoo2a/sim4da/TerminationTest.java b/src/test/java/dev/oxoo2a/sim4da/TerminationTest.java
new file mode 100644
index 0000000..db810be
--- /dev/null
+++ b/src/test/java/dev/oxoo2a/sim4da/TerminationTest.java
@@ -0,0 +1,50 @@
+package dev.oxoo2a.sim4da;
+
+import dev.oxoo2a.sim4da.nodes.PassAlongRandomNode;
+import dev.oxoo2a.sim4da.nodes.TerminatorControlVectorNode;
+import dev.oxoo2a.sim4da.nodes.TerminatorDoubleCountingNode;
+import dev.oxoo2a.sim4da.times.LamportTime;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Test PassAlongRandomNode with TerminatorControlVectorNode and TerminatorDoubleCountingNode
+ * @author Tessa Steinigke
+ */
+public class TerminationTest {
+
+    private static final int n_nodes = 10;
+    private static final int p_prob = 1;
+
+    /***
+     * Tests the termination
+     */
+    @Test
+    public void termination() {
+        Simulator s = Simulator.createDefaultSimulator(n_nodes+2);
+        // Init nodes
+        for (int id=0; id<n_nodes; id++) {
+            PassAlongRandomNode n = new PassAlongRandomNode(id, new LamportTime(), n_nodes, p_prob);
+            s.attachNode(id,n);
+        }
+        // Terminator watchers
+        TerminatorDoubleCountingNode w_dd = new TerminatorDoubleCountingNode(n_nodes, n_nodes);
+        s.attachNode(w_dd.myId, w_dd);
+        TerminatorControlVectorNode w_cv = new TerminatorControlVectorNode(n_nodes + 1, n_nodes);
+        s.attachNode(w_cv.myId, w_cv);
+        // Start
+        try {
+            s.runSimulation(2);
+        }
+        catch (InstantiationException ignored) {
+            fail("Not all nodes instantiated");
+        }
+
+        if(!w_dd.hasTermination_detected())
+            fail("Double counting methode did not detect termination");
+        if(!w_cv.hasTermination_detected())
+            fail("Following vector methode did not detect termination");
+    }
+
+}
diff --git a/src/test/java/dev/oxoo2a/sim4da/TokenRingTest.java b/src/test/java/dev/oxoo2a/sim4da/TokenRingTest.java
new file mode 100644
index 0000000..86c49e5
--- /dev/null
+++ b/src/test/java/dev/oxoo2a/sim4da/TokenRingTest.java
@@ -0,0 +1,30 @@
+package dev.oxoo2a.sim4da;
+
+import dev.oxoo2a.sim4da.nodes.TokenRingNode;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+public class TokenRingTest {
+
+    private static final int n_nodes = 10;
+
+    /***
+     * Tests the token Ring
+     */
+    @Test
+    public void tokenRingTest() {
+        Simulator s = Simulator.createDefaultSimulator(n_nodes);
+        for (int id=0; id<n_nodes; id++) {
+            TokenRingNode trn = new TokenRingNode(id);
+            s.attachNode(id,trn);
+        }
+        try {
+            s.runSimulation(2);
+        }
+        catch (InstantiationException ignored) {
+            fail("Not all nodes instantiated");
+        }
+    }
+
+}
diff --git a/src/test/java/dev/oxoo2a/sim4da/BroadcastNode.java b/src/test/java/dev/oxoo2a/sim4da/nodes/BroadcastNode.java
similarity index 93%
rename from src/test/java/dev/oxoo2a/sim4da/BroadcastNode.java
rename to src/test/java/dev/oxoo2a/sim4da/nodes/BroadcastNode.java
index 0f73569..ce0ca2b 100644
--- a/src/test/java/dev/oxoo2a/sim4da/BroadcastNode.java
+++ b/src/test/java/dev/oxoo2a/sim4da/nodes/BroadcastNode.java
@@ -1,4 +1,8 @@
-package dev.oxoo2a.sim4da;
+package dev.oxoo2a.sim4da.nodes;
+
+import dev.oxoo2a.sim4da.Message;
+import dev.oxoo2a.sim4da.Network;
+import dev.oxoo2a.sim4da.Node;
 
 import java.util.Random;
 
diff --git a/src/test/java/dev/oxoo2a/sim4da/nodes/NodeWithTimeRandom.java b/src/test/java/dev/oxoo2a/sim4da/nodes/NodeWithTimeRandom.java
new file mode 100644
index 0000000..a6b71e3
--- /dev/null
+++ b/src/test/java/dev/oxoo2a/sim4da/nodes/NodeWithTimeRandom.java
@@ -0,0 +1,84 @@
+package dev.oxoo2a.sim4da.nodes;
+
+import dev.oxoo2a.sim4da.Message;
+import dev.oxoo2a.sim4da.Network;
+import dev.oxoo2a.sim4da.NodeWithTime;
+import dev.oxoo2a.sim4da.Time;
+
+import java.util.Random;
+
+/***
+ * A node with a logic clock that performs some random actions when a event is triggered
+ */
+public class NodeWithTimeRandom extends NodeWithTime {
+
+    private final int n_nodes;
+
+    public NodeWithTimeRandom(int id, Time time, int n_nodes){
+        super(id, time, true);
+        this.n_nodes = n_nodes;
+    }
+
+
+
+    /***
+     * The inner event of the node is sleeping/pausing for some milliseconds
+     */
+    protected void innerEvent() {
+        time.incrementMyTime();
+        emit("%d: perform Inner Event at %s",myId,time.toString());
+        try {
+            Thread.sleep(2 * 100L);
+        }
+        catch (InterruptedException ignored) {}
+    }
+
+    /***
+     * When a message is received a random number of events are performed.
+     * By random the events can be INNER or SEND_MESSAGE.
+     * At leased one SEND_MESSAGE must be performed so that the network continuous to do something.
+     */
+    protected void handleReceivingMessage() {
+        boolean sendPerformed = false;
+
+        Random rand = new Random();
+        // Execute a random number of events
+        int numberOfRandomEvents = rand.nextInt(3);
+        for(int i = 0; i <= numberOfRandomEvents; i++) {
+            // Get a random event type
+            int randEvent_i = rand.nextInt(4);
+            if (randEvent_i == 1){
+                // send message to a random receiving node
+                int randReceiverNodeId = rand.nextInt(n_nodes);
+                if(randReceiverNodeId != myId){
+                    sendUnicast(randReceiverNodeId, new Message());
+                    sendPerformed = true;
+                }
+            }else{
+                // do inner event
+                innerEvent();
+            }
+        }
+
+        // Make sure that at leased one message was send
+        if(!sendPerformed){
+            sendUnicast((myId+1) % n_nodes, new Message());
+        }
+    }
+
+
+    @Override
+    protected void main() {
+        //Message m = new Message();
+        if (myId == 0) {
+            sendUnicast(1, new Message());
+        }
+        while (true) {
+            // Listen for messages
+            Network.Message m_raw = receive();
+            if (m_raw == null) break;
+            // Message received
+            handleReceivingMessage();
+        }
+    }
+}
diff --git a/src/test/java/dev/oxoo2a/sim4da/nodes/PassAlongRandomNode.java b/src/test/java/dev/oxoo2a/sim4da/nodes/PassAlongRandomNode.java
new file mode 100644
index 0000000..ccced12
--- /dev/null
+++ b/src/test/java/dev/oxoo2a/sim4da/nodes/PassAlongRandomNode.java
@@ -0,0 +1,107 @@
+package dev.oxoo2a.sim4da.nodes;
+
+import dev.oxoo2a.sim4da.*;
+
+import java.util.Arrays;
+import java.util.Random;
+
+/***
+ * Jeder Aktor beginnt mit einer aktiven Phase, in der er mit einer parametrisierten
+ * Wahrscheinlichkeit p eine Nachricht an einen zufällig ausgewählten anderen Aktor sendet. Anschließend wechselt der sendende
+ * Aktor in den passiven Zustand. Ein passiver Aktor kann durch den Empfang einer Nachricht wieder aktiv werden. In diesem Fall
+ * sendet er erneut mit der gegebenen Wahrscheinlichkeit p eine Nachricht an einen neu ausgewählten zufälligen Aktor. Die
+ * Wahrscheinlichkeit p ist für alle n Aktoren gleich und soll über den zeitlichen Verlauf der Simulation gegen 0 konvergieren.
+ * @author Tessa Steinigke
+ */
+public class PassAlongRandomNode extends NodeWithTime {
+
+    private final int n_nodes;
+    // 100% = 1; 50% = 2; 25% = 4; ...
+    private int p_prob;
+    // converges to 0
+    private static final int p_increase_step = 1;
+
+    private boolean status_active = true;
+    private int c_send = 0;
+    private int c_received = 0;
+    private int[] v_messages;
+
+    /***
+     *
+     * @param my_id - node id
+     * @param time - node time instance
+     * @param n_nodes - number of nodes that are communicating (without watchers)
+     * @param p_prob - starting probability to pass along a received message (1 = 100%, 2 = 50%, ...)
+     */
+    public PassAlongRandomNode(int my_id, Time time, int n_nodes, int p_prob) {
+        super(my_id, time);
+        this.n_nodes = n_nodes;
+        this.p_prob = p_prob;
+        v_messages = new int[n_nodes];
+    }
+
+    /**
+     * Send a new message to a random receiver by the given probability
+     */
+    private void send_pass_along(){
+        Random rand = new Random();
+        // Probability to send message
+        int p = rand.nextInt(p_prob);
+        if(p == 0){
+            // Send
+            int rand_receiver = rand.nextInt(n_nodes);
+            sendUnicast(rand_receiver, new Message());
+            c_send++;
+            v_messages[rand_receiver] += 1;
+            p_prob += p_increase_step;
+            if(p_prob < 0) p_prob = 0;
+            status_active = false;
+        }else
+            emit("End of one message passing: %d", myId);
+    }
+
+    /**
+     * Send the requested status to a watcher
+     * @param request - request type
+     * @param requester_id - watcher node id
+     */
+    private void send_my_status(String request, int requester_id){
+        if(request.equals("send/received")){
+            // Status values requested
+            Message m_status = new Message();
+            m_status.add("send", c_send);
+            m_status.add("received", c_received);
+            m_status.add("status", (status_active) ? "active" : "passive");
+            sendUnicast(requester_id, m_status);
+        }else if(request.equals("vector")){
+            Message m_status = new Message();
+            m_status.add("vector", Arrays.toString(v_messages));
+            v_messages = new int[n_nodes];
+            sendUnicast(requester_id, m_status);
+        }
+    }
+
+    @Override
+    protected void main() {
+        Message m;
+        send_pass_along();
+        while (true) {
+            // Listen for messages
+            Network.Message m_raw = receive();
+            if (m_raw == null) break;
+
+            // Message received
+            m = Message.fromJson(m_raw.payload);
+            String request = m.query("request");
+            if(request == null) {
+                // Basic message
+                if(status_active) break;
+                c_received++;
+                v_messages[myId] -= 1;
+                send_pass_along();
+            }else
+                // Special requests
+                send_my_status(request, m_raw.sender_id);
+        }
+    }
+}
diff --git a/src/test/java/dev/oxoo2a/sim4da/nodes/Terminator.java b/src/test/java/dev/oxoo2a/sim4da/nodes/Terminator.java
new file mode 100644
index 0000000..1304222
--- /dev/null
+++ b/src/test/java/dev/oxoo2a/sim4da/nodes/Terminator.java
@@ -0,0 +1,39 @@
+package dev.oxoo2a.sim4da.nodes;
+
+import dev.oxoo2a.sim4da.Message;
+import dev.oxoo2a.sim4da.Network;
+import dev.oxoo2a.sim4da.Node;
+
+public abstract class Terminator extends Node {
+
+    protected final int n_nodes;
+
+    protected boolean termination_detected = false;
+
+    public Terminator(int my_id, int n_nodes) {
+        super(my_id);
+        this.n_nodes = n_nodes;
+    }
+
+    protected abstract void send_request();
+
+    protected abstract void receive_status(Message m);
+
+    public boolean hasTermination_detected(){
+        return termination_detected;
+    }
+
+    @Override
+    protected void main() {
+        send_request();
+        while (true) {
+            if(termination_detected) break;
+            // Listen for messages
+            Network.Message m_raw = receive();
+            if (m_raw == null) break;
+            // Message received
+            receive_status(Message.fromJson(m_raw.payload));
+        }
+    }
+
+}
diff --git a/src/test/java/dev/oxoo2a/sim4da/nodes/TerminatorControlVectorNode.java b/src/test/java/dev/oxoo2a/sim4da/nodes/TerminatorControlVectorNode.java
new file mode 100644
index 0000000..c25de7d
--- /dev/null
+++ b/src/test/java/dev/oxoo2a/sim4da/nodes/TerminatorControlVectorNode.java
@@ -0,0 +1,51 @@
+package dev.oxoo2a.sim4da.nodes;
+
+import dev.oxoo2a.sim4da.Message;
+import dev.oxoo2a.sim4da.Network;
+import dev.oxoo2a.sim4da.Node;
+
+/**
+ * Nachlaufender Kontrollvector zur Bestimmung der Terminierung
+ * @author Tessa Steinigke
+ */
+public class TerminatorControlVectorNode extends Terminator {
+
+    private final int[] statistics;
+    private int node_request_next_statistics = 0;
+
+    public TerminatorControlVectorNode(int my_id, int n_nodes) {
+        super(my_id, n_nodes);
+        statistics = new int[n_nodes];
+    }
+
+    protected void send_request(){
+        Message m =  new Message();
+        m.add("request","vector");
+        sendUnicast(node_request_next_statistics, m);
+        node_request_next_statistics = (node_request_next_statistics +1) % n_nodes;
+    }
+
+    protected void receive_status(Message m){
+        if(m.query("request")!= null) return; // Ignore requests
+
+        String sender_v_s = m.query("vector");
+        sender_v_s = sender_v_s.substring(1, sender_v_s.length()-1);
+        String[] sender_v = sender_v_s.split(", ");
+        boolean running = false;
+        for (int i = 0; i < statistics.length; i++){
+            statistics[i] += Integer.parseInt(sender_v[i]);
+            if(statistics[i] > 0) running = true;
+        }
+
+        // Check termination
+        if(!running){
+            // TERMINATED
+            termination_detected = true;
+            emit("!! TERMINATION DETECTED BY FOLLOWING-VECTOR-METHODE");
+        }else{
+            // Not terminated
+            send_request();
+        }
+    }
+
+}
diff --git a/src/test/java/dev/oxoo2a/sim4da/nodes/TerminatorDoubleCountingNode.java b/src/test/java/dev/oxoo2a/sim4da/nodes/TerminatorDoubleCountingNode.java
new file mode 100644
index 0000000..1249ea2
--- /dev/null
+++ b/src/test/java/dev/oxoo2a/sim4da/nodes/TerminatorDoubleCountingNode.java
@@ -0,0 +1,81 @@
+package dev.oxoo2a.sim4da.nodes;
+
+import dev.oxoo2a.sim4da.*;
+
+/**
+ * Doppelzählverfahren zur Bestimmung der Terminierung
+ * @author Tessa Steinigke
+ */
+public class TerminatorDoubleCountingNode extends Terminator {
+
+    /**
+     * [Interval 1: sums of send|received|active],
+     * [Interval 2: sums of send|received|active]
+     */
+    private int[][] statistics;
+    private int statistics_interval = 0;
+    private int c_statistics_missing = n_nodes;
+
+    public TerminatorDoubleCountingNode(int my_id, int n_nodes) {
+        super(my_id, n_nodes);
+        statistics = new int[2][3];
+    }
+
+    protected void send_request(){
+        c_statistics_missing = n_nodes;
+        Message m =  new Message();
+        m.add("request","send/received");
+        sendBroadcast(m);
+    }
+
+    protected void receive_status(Message m){
+        if(m.query("request")!= null) return; // Ignore requests
+
+        c_statistics_missing--;
+        // Add statistics
+        statistics[statistics_interval][0] += Integer.parseInt(m.query("send"));
+        statistics[statistics_interval][1] += Integer.parseInt(m.query("received"));
+        statistics[statistics_interval][2] += (m.query("status").equals("active") ? 1 : 0 );
+
+        // Analyse
+        if(c_statistics_missing == 0){
+            // All answers received
+            if(statistics_interval == 0) {
+                // first loop
+                statistics_interval = 1;
+                send_request();
+                return;
+            }
+
+            //emit("0 missing: (%d,%d,%d),(%d,%d,%d)", stati[0][0], stati[0][1], stati[0][2], stati[1][0], stati[1][1], stati[1][2]);
+
+            // Check terminated
+            // 1. check all passive
+            boolean terminated = (statistics[0][2] + statistics[1][2] == 0);
+            if(terminated){
+                //2. Check values
+                int val = statistics[0][0];
+                terminated = (val == statistics[0][1]) & (val == statistics[1][0]) & (val == statistics[1][1]);
+                if(terminated){
+                    // TERMINATED
+                    termination_detected = true;
+                    emit("!! TERMINATION DETECTED BY DOUBLE-COUNTING-METHODE");
+                    return;
+                }
+            }
+
+            // Not terminated
+            if(statistics[1][0] == statistics[1][1]){
+                // Last attempt could indicate termination
+                statistics[0] = statistics[1]; // shift last to new first
+                statistics[1] = new int[3]; // empty new last
+            }else{
+                // Last attempt already indicates no termination -> can be deleted
+                statistics = new int[2][3];
+                statistics_interval = 0;
+            }
+            send_request();
+        }
+    }
+
+}
diff --git a/src/test/java/dev/oxoo2a/sim4da/nodes/TokenRingNode.java b/src/test/java/dev/oxoo2a/sim4da/nodes/TokenRingNode.java
new file mode 100644
index 0000000..8f0c65a
--- /dev/null
+++ b/src/test/java/dev/oxoo2a/sim4da/nodes/TokenRingNode.java
@@ -0,0 +1,37 @@
+package dev.oxoo2a.sim4da.nodes;
+
+import dev.oxoo2a.sim4da.Message;
+import dev.oxoo2a.sim4da.Network;
+import dev.oxoo2a.sim4da.Node;
+
+public class TokenRingNode extends Node {
+
+    public TokenRingNode(int my_id) {
+        super(my_id);
+    }
+
+    @Override
+    protected void main() {
+        Message m = new Message();
+        if (myId == 0) {
+            // Send first message
+            m.add("counter",0);
+            sendUnicast(1,m);
+        }
+        while (true) {
+            // Listen for messages
+            Network.Message m_raw = receive();
+            if (m_raw == null) break;
+            // Message received
+            m = Message.fromJson(m_raw.payload);
+            int counter = Integer.parseInt(m.query("counter"));
+            emit("%d: counter==%d",myId,counter);
+            // Token increased
+            counter++;
+            m.add("counter",counter);
+            // Next message send
+            sendUnicast((myId+1) % numberOfNodes(),m);
+        }
+    }
+
+}