diff --git a/src/main/java/cli/SimulatorScript.java b/src/main/java/cli/SimulatorScript.java
index 37f008176d1cc1b1ed241df223fda9488095b4ea..86f6b941d501b8e93beec97664de20283016b4e4 100644
--- a/src/main/java/cli/SimulatorScript.java
+++ b/src/main/java/cli/SimulatorScript.java
@@ -53,7 +53,9 @@ import ui.MainGUI;
 import ui.util.IconManager;
 import avatartranslator.*;
 
+import java.io.BufferedInputStream;
 import java.io.File;
+import java.io.FileInputStream;
 import java.util.BitSet;
 import java.util.*;
 
@@ -66,7 +68,8 @@ import java.util.*;
  * @author Ludovic APVRILLE
  */
 public class SimulatorScript extends Command  {
-
+    private static String[] channels = {"wsend_train_position1_Frame_R", "wframeBuffer", "rframeBuffer", "wcomputationResult",
+            "rcontrolData"};
 
 
     public SimulatorScript() {
@@ -148,20 +151,85 @@ public class SimulatorScript extends Command  {
 
 
         // Opens the two files
+        boolean running = true;
+        BufferedInputStream reader = new BufferedInputStream(new FileInputStream( inputFile ) );
+        String readString = "";
+        String line = "";
+        boolean first = true;
+        double lastValue = 0;
 
+        try {
+            while (running) {
+                if (reader.available() > 0) {
+                    char c = (char) reader.read();
+
+                    // regular character?
+                    if (String.valueOf(c).matches(".")) {
+                        readString += c;
+                    } else {
+                        // End of line
+                        // Must handle the line
+                        line = readString.trim();
+                        TraceManager.addDev("Line read:" + line);
+                        readString = "";
+                        String lines[] = line.split(" ");
+                        if (lines.length > 1) {
+                            double value1 = Double.parseDouble(lines[1]);
+                            if (first) {
+                                first = false;
+                                lastValue = value1;
+                            } else {
+                                if (value1 != lastValue) {
+                                    lastValue = value1;
+                                    double time1 = Double.parseDouble(lines[0]);
+                                    // Run simulation until time1
+                                    runSimulationTo(rc, time1);
+                                    // Remove all transactions
+                                    removeAllTransactions(rc);
+                                    // Wait for  to occur
+
+                                    // Get time of event1
+
+                                    // Wait for event2 to occur
+                                    // Get time of event2.
+                                    // Append to file2 time2-time1
+                                }
+                            }
+                        }
+
+                    }
+                }
+
+                // Nothing new in the file
+                else {
+                    try {
+                        Thread.sleep(500);
+                    } catch (InterruptedException ex) {
+                        running = false;
+                    }
+                }
+            }
+        } catch (RemoteConnectionException rce) {
+            return "Connection failure";
+        }
 
-        // Loop: as soon as there is a new input, read it, see if value change -> compute
-        // simulation time. Append this simulation time to the output file
-        // To compute the simulation time: simulate until read time. Erase all past transactions
-        // Then wait for event1.
-        // and note the time of event1.
-        // Then execute until event2. Note the new time time2. Compute (time2-time1)
-        // append time2-time1 to the output file
 
         return null;
 
     }
 
+    private void runSimulationTo(RemoteConnection rc, double time1) throws RemoteConnectionException {
+        // Must convert in clock cycles
+        // We assume 200 MHz
+        // We assume time is in ms
+        long nbOfCycles = (long)(200000 * time1);
+        rc.send("1 5 " + nbOfCycles);
+
+    }
+
+    private void removeAllTransactions(RemoteConnection rc) throws RemoteConnectionException {
+        rc.send("26");
+    }
 
 
 
diff --git a/src/main/java/common/ConfigurationTTool.java b/src/main/java/common/ConfigurationTTool.java
index 6282a876c466f271e5babdf0fb113966f05ca603..8f8a8dc023859d1a0f946a97fdab663e69085ec0 100755
--- a/src/main/java/common/ConfigurationTTool.java
+++ b/src/main/java/common/ConfigurationTTool.java
@@ -1736,6 +1736,8 @@ public class ConfigurationTTool {
 
         } catch (UnsatisfiedLinkError e) {
             return ("Z3 libs " + ConfigurationTTool.Z3LIBS + " could not be loaded\n");
+        } catch (IllegalArgumentException iae) {
+            return ("Z3 libs " + ConfigurationTTool.Z3LIBS + " could not be used\n");
         }
 
         return null;
diff --git a/ttool/src/test/java/tmltranslator/dsez3engine/InputInstanceTest.java b/ttool/src/test/java/tmltranslator/dsez3engine/InputInstanceTest.java
index 3a4701c381fea1e983f0054b67541370ccb3ff90..d1bde753a7488f7f82a3320e655a462d5b58d113 100644
--- a/ttool/src/test/java/tmltranslator/dsez3engine/InputInstanceTest.java
+++ b/ttool/src/test/java/tmltranslator/dsez3engine/InputInstanceTest.java
@@ -1,219 +1,217 @@
 package tmltranslator.dsez3engine;
 
-import com.microsoft.z3.*;
+import com.microsoft.z3.Log;
 import common.ConfigurationTTool;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import tmltranslator.*;
+import ui.TGComponent;
 
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import myutil.TraceManager;
-import ui.TGComponent;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 public class InputInstanceTest {
 
-  private TMLArchitecture tmla;
-  private TMLModeling<TGComponent> tmlm;
-  private InputInstance inputInstance;
-  private OptimizationModel optimizationModel;
+    private TMLArchitecture tmla;
+    private TMLModeling<TGComponent> tmlm;
+    private InputInstance inputInstance;
+    private OptimizationModel optimizationModel;
 
-  @Before
-  public void setUpTest() {
+    @Before
+    public void setUpTest() {
 
-    tmla = setUpTMLArchitecture();
-    tmlm = setUpTMLModeling();
+        tmla = setUpTMLArchitecture();
+        tmlm = setUpTMLModeling();
 
-    inputInstance = new InputInstance(tmla, tmlm);
-    optimizationModel = new OptimizationModel(inputInstance);
-  }
+        inputInstance = new InputInstance(tmla, tmlm);
+        optimizationModel = new OptimizationModel(inputInstance);
+    }
 
-  private TMLModeling<TGComponent> setUpTMLModeling() {
+    private TMLModeling<TGComponent> setUpTMLModeling() {
 
-    tmlm = new TMLModeling<TGComponent>();
+        tmlm = new TMLModeling<TGComponent>();
 
 
-    TMLTask taskA = new TMLTask("task__A", null, null);
-    TMLTask taskB = new TMLTask("task__B", null, null);
-    TMLTask taskD = new TMLTask("task__D", null, null);
-    TMLTask taskE = new TMLTask("task__E", null, null);
+        TMLTask taskA = new TMLTask("task__A", null, null);
+        TMLTask taskB = new TMLTask("task__B", null, null);
+        TMLTask taskD = new TMLTask("task__D", null, null);
+        TMLTask taskE = new TMLTask("task__E", null, null);
 
-    //filling activity diagrams of tasks
+        //filling activity diagrams of tasks
 
-    //taskA
-    TMLActivityElementWithAction firstA = new TMLExecI("execiA", null);
-    firstA.setAction("150");
-    taskA.getActivityDiagram().setFirst(firstA);
+        //taskA
+        TMLActivityElementWithAction firstA = new TMLExecI("execiA", null);
+        firstA.setAction("150");
+        taskA.getActivityDiagram().setFirst(firstA);
 
-    TMLActivityElement AwB = new TMLWriteChannel("AwB", null);
-    taskA.getActivityDiagram().addLinkElement(firstA, AwB);
-    taskA.getActivityDiagram().addElement(AwB);
+        TMLActivityElement AwB = new TMLWriteChannel("AwB", null);
+        taskA.getActivityDiagram().addLinkElement(firstA, AwB);
+        taskA.getActivityDiagram().addElement(AwB);
 
-    TMLActivityElement AwD = new TMLWriteChannel("AwD", null);
-    taskA.getActivityDiagram().addLinkElement(AwB, AwD);
-    taskA.getActivityDiagram().addElement(AwD);
+        TMLActivityElement AwD = new TMLWriteChannel("AwD", null);
+        taskA.getActivityDiagram().addLinkElement(AwB, AwD);
+        taskA.getActivityDiagram().addElement(AwD);
 
-    //taskB
-    TMLActivityElement firstB = new TMLReadChannel("BrA", null);
-    taskB.getActivityDiagram().setFirst(firstB);
+        //taskB
+        TMLActivityElement firstB = new TMLReadChannel("BrA", null);
+        taskB.getActivityDiagram().setFirst(firstB);
 
-    TMLActivityElementWithAction execiB = new TMLExecI("execiB", null);
-    execiB.setAction("100");
-    taskB.getActivityDiagram().addLinkElement(firstB, execiB);
-    taskB.getActivityDiagram().addElement(execiB);
+        TMLActivityElementWithAction execiB = new TMLExecI("execiB", null);
+        execiB.setAction("100");
+        taskB.getActivityDiagram().addLinkElement(firstB, execiB);
+        taskB.getActivityDiagram().addElement(execiB);
 
-    TMLActivityElement BwE = new TMLWriteChannel("BwE", null);
-    taskB.getActivityDiagram().addLinkElement(execiB, BwE);
-    taskB.getActivityDiagram().addElement(BwE);
+        TMLActivityElement BwE = new TMLWriteChannel("BwE", null);
+        taskB.getActivityDiagram().addLinkElement(execiB, BwE);
+        taskB.getActivityDiagram().addElement(BwE);
 
-    //taskD
-    TMLActivityElement firstD = new TMLReadChannel("DrA", null);
-    taskD.getActivityDiagram().setFirst(firstD);
+        //taskD
+        TMLActivityElement firstD = new TMLReadChannel("DrA", null);
+        taskD.getActivityDiagram().setFirst(firstD);
 
-    TMLActivityElementWithAction execiD = new TMLExecI("execiD", null);
-    execiD.setAction("100");
-    taskD.getActivityDiagram().addLinkElement(firstD, execiD);
-    taskD.getActivityDiagram().addElement(execiD);
+        TMLActivityElementWithAction execiD = new TMLExecI("execiD", null);
+        execiD.setAction("100");
+        taskD.getActivityDiagram().addLinkElement(firstD, execiD);
+        taskD.getActivityDiagram().addElement(execiD);
 
-    TMLActivityElement DwE = new TMLWriteChannel("DwE", null);
-    taskD.getActivityDiagram().addLinkElement(execiD, DwE);
-    taskD.getActivityDiagram().addElement(DwE);
+        TMLActivityElement DwE = new TMLWriteChannel("DwE", null);
+        taskD.getActivityDiagram().addLinkElement(execiD, DwE);
+        taskD.getActivityDiagram().addElement(DwE);
 
-    //taskE
-    TMLActivityElement firstE = new TMLReadChannel("ErB", null);
-    taskE.getActivityDiagram().setFirst(firstE);
+        //taskE
+        TMLActivityElement firstE = new TMLReadChannel("ErB", null);
+        taskE.getActivityDiagram().setFirst(firstE);
 
-    TMLActivityElement ErD = new TMLReadChannel("ErD", null);
-    taskE.getActivityDiagram().addLinkElement(firstE, ErD);
-    taskE.getActivityDiagram().addElement(ErD);
+        TMLActivityElement ErD = new TMLReadChannel("ErD", null);
+        taskE.getActivityDiagram().addLinkElement(firstE, ErD);
+        taskE.getActivityDiagram().addElement(ErD);
 
-    TMLActivityElementWithAction execiE = new TMLExecI("execiE", null);
-    execiE.setAction("50");
-    taskE.getActivityDiagram().addLinkElement(ErD, execiE);
-    taskE.getActivityDiagram().addElement(execiE);
+        TMLActivityElementWithAction execiE = new TMLExecI("execiE", null);
+        execiE.setAction("50");
+        taskE.getActivityDiagram().addLinkElement(ErD, execiE);
+        taskE.getActivityDiagram().addElement(execiE);
 
 
-    taskA.addOperation("generic");
-    taskB.addOperation("fft");
-    taskD.addOperation("fft");
-    taskE.addOperation("generic");
+        taskA.addOperation("generic");
+        taskB.addOperation("fft");
+        taskD.addOperation("fft");
+        taskE.addOperation("generic");
 
-    //creating channels
-    TMLChannel ab = new TMLChannel("ab", null);
-    TMLChannel ad = new TMLChannel("ad", null);
-    TMLChannel be = new TMLChannel("be", null);
-    TMLChannel de = new TMLChannel("de", null);
+        //creating channels
+        TMLChannel ab = new TMLChannel("ab", null);
+        TMLChannel ad = new TMLChannel("ad", null);
+        TMLChannel be = new TMLChannel("be", null);
+        TMLChannel de = new TMLChannel("de", null);
 
-    taskA.addWriteTMLChannel(ab);
-    taskA.addWriteTMLChannel(ad);
+        taskA.addWriteTMLChannel(ab);
+        taskA.addWriteTMLChannel(ad);
 
-    taskB.addReadTMLChannel(ab);
-    taskB.addWriteTMLChannel(be);
+        taskB.addReadTMLChannel(ab);
+        taskB.addWriteTMLChannel(be);
 
-    taskD.addReadTMLChannel(ad);
-    taskD.addWriteTMLChannel(de);
+        taskD.addReadTMLChannel(ad);
+        taskD.addWriteTMLChannel(de);
 
-    taskE.addReadTMLChannel(be);
-    taskE.addReadTMLChannel(de);
+        taskE.addReadTMLChannel(be);
+        taskE.addReadTMLChannel(de);
 
-    ab.setTasks(taskA, taskB);
-    ad.setTasks(taskA, taskD);
-    be.setTasks(taskB, taskE);
-    de.setTasks(taskD, taskE);
+        ab.setTasks(taskA, taskB);
+        ad.setTasks(taskA, taskD);
+        be.setTasks(taskB, taskE);
+        de.setTasks(taskD, taskE);
 
-    ab.setNumberOfSamples(2);
-    ad.setNumberOfSamples(2);
-    be.setNumberOfSamples(5);
-    de.setNumberOfSamples(5);
+        ab.setNumberOfSamples(2);
+        ad.setNumberOfSamples(2);
+        be.setNumberOfSamples(5);
+        de.setNumberOfSamples(5);
 
-    tmlm.addTask(taskA);
-    tmlm.addTask(taskB);
-    tmlm.addTask(taskD);
-    tmlm.addTask(taskE);
+        tmlm.addTask(taskA);
+        tmlm.addTask(taskB);
+        tmlm.addTask(taskD);
+        tmlm.addTask(taskE);
 
-    tmlm.addChannel(ab);
-    tmlm.addChannel(ad);
-    tmlm.addChannel(be);
-    tmlm.addChannel(de);
+        tmlm.addChannel(ab);
+        tmlm.addChannel(ad);
+        tmlm.addChannel(be);
+        tmlm.addChannel(de);
 
 
-    return tmlm;
-  }
+        return tmlm;
+    }
 
 
-  private TMLArchitecture setUpTMLArchitecture() {
+    private TMLArchitecture setUpTMLArchitecture() {
 
-    HwExecutionNode mainCPU = new HwCPU("MainCPU");
-    HwMemory mainMem = new HwMemory("mainMem");
+        HwExecutionNode mainCPU = new HwCPU("MainCPU");
+        HwMemory mainMem = new HwMemory("mainMem");
 
-    HwExecutionNode dsp = new HwCPU("dsp");
-    HwMemory dspMem = new HwMemory("dspMem");
+        HwExecutionNode dsp = new HwCPU("dsp");
+        HwMemory dspMem = new HwMemory("dspMem");
 
-    HwBus bus0 = new HwBus("bus0");
-    HwBus bus1 = new HwBus("bus1");
+        HwBus bus0 = new HwBus("bus0");
+        HwBus bus1 = new HwBus("bus1");
 
 
-    HwLink maincpu_bus0 = new HwLink("maincpu_bus0");
-    HwLink bus0_cpumem = new HwLink("bus0_cpumem");
+        HwLink maincpu_bus0 = new HwLink("maincpu_bus0");
+        HwLink bus0_cpumem = new HwLink("bus0_cpumem");
 
-    HwLink dsp_bus1 = new HwLink("dsp_bus1");
-    HwLink bus1_dspmem = new HwLink("bus1_dspmem");
+        HwLink dsp_bus1 = new HwLink("dsp_bus1");
+        HwLink bus1_dspmem = new HwLink("bus1_dspmem");
 
-    mainCPU.execiTime = 2;
-    dsp.execiTime = 1;
+        mainCPU.execiTime = 2;
+        dsp.execiTime = 1;
 
 
-    mainCPU.setOperation("generic fft");
+        mainCPU.setOperation("generic fft");
 
-    mainMem.memorySize = 200;
+        mainMem.memorySize = 200;
 
-    dsp.setOperation("fft");
-    dspMem.memorySize = 100;
+        dsp.setOperation("fft");
+        dspMem.memorySize = 100;
 
-    maincpu_bus0.hwnode = mainCPU;
-    maincpu_bus0.bus = bus0;
+        maincpu_bus0.hwnode = mainCPU;
+        maincpu_bus0.bus = bus0;
 
-    bus0_cpumem.bus = bus0;
-    bus0_cpumem.hwnode = mainMem;
+        bus0_cpumem.bus = bus0;
+        bus0_cpumem.hwnode = mainMem;
 
-    dsp_bus1.hwnode = dsp;
-    dsp_bus1.bus = bus1;
+        dsp_bus1.hwnode = dsp;
+        dsp_bus1.bus = bus1;
 
-    bus1_dspmem.bus = bus1;
-    bus1_dspmem.hwnode = dspMem;
+        bus1_dspmem.bus = bus1;
+        bus1_dspmem.hwnode = dspMem;
 
 
-    tmla = new TMLArchitecture();
+        tmla = new TMLArchitecture();
 
-    tmla.addHwNode(mainCPU);
-    tmla.addHwNode(dsp);
-    tmla.addHwNode(mainMem);
-    tmla.addHwNode(dspMem);
-    tmla.addHwNode(bus0);
-    tmla.addHwNode(bus1);
-    tmla.addHwLink(maincpu_bus0);
-    tmla.addHwLink(bus0_cpumem);
-    tmla.addHwLink(dsp_bus1);
-    tmla.addHwLink(bus1_dspmem);
+        tmla.addHwNode(mainCPU);
+        tmla.addHwNode(dsp);
+        tmla.addHwNode(mainMem);
+        tmla.addHwNode(dspMem);
+        tmla.addHwNode(bus0);
+        tmla.addHwNode(bus1);
+        tmla.addHwLink(maincpu_bus0);
+        tmla.addHwLink(bus0_cpumem);
+        tmla.addHwLink(dsp_bus1);
+        tmla.addHwLink(bus1_dspmem);
 
-    return tmla;
-  }
+        return tmla;
+    }
 
-  @Test
-  public void findOptimizedMapping() {
+    @Test
+    public void findOptimizedMapping() {
 
         String error = ConfigurationTTool.loadZ3Libs();
         if (error != null) {
             // we cannot run the test since Z3 is not installed
             return;
         }
-      OptimizationResult result = optimizationModel.findOptimizedMapping();
+        OptimizationResult result = optimizationModel.findOptimizedMapping();
 
-      Log.close();
+        Log.close();
       /*if (Log.isOpen())
         TraceManager.addDev("Log is still open!");
     } catch (Z3Exception ex) {
@@ -227,128 +225,127 @@ public class InputInstanceTest {
       ex.printStackTrace(System.out);
     }*/
 
-    assertEquals(1, optimizationModel.getOptimizedSolutionX().get("X[task__A][MainCPU] = ").intValue());
-    assertEquals(0, optimizationModel.getOptimizedSolutionX().get("X[task__A][dsp] = ").intValue());
-    assertEquals(0, optimizationModel.getOptimizedSolutionX().get("X[task__B][MainCPU] = ").intValue());
-    assertEquals(1, optimizationModel.getOptimizedSolutionX().get("X[task__B][dsp] = ").intValue());
-    assertEquals(0, optimizationModel.getOptimizedSolutionX().get("X[task__D][MainCPU] = ").intValue());
-    assertEquals(1, optimizationModel.getOptimizedSolutionX().get("X[task__D][dsp] = ").intValue());
-    assertEquals(1, optimizationModel.getOptimizedSolutionX().get("X[task__E][MainCPU] = ").intValue());
-    assertEquals(0, optimizationModel.getOptimizedSolutionX().get("X[task__E][dsp] = ").intValue());
+        assertEquals(1, optimizationModel.getOptimizedSolutionX().get("X[task__A][MainCPU] = ").intValue());
+        assertEquals(0, optimizationModel.getOptimizedSolutionX().get("X[task__A][dsp] = ").intValue());
+        assertEquals(0, optimizationModel.getOptimizedSolutionX().get("X[task__B][MainCPU] = ").intValue());
+        assertEquals(1, optimizationModel.getOptimizedSolutionX().get("X[task__B][dsp] = ").intValue());
+        assertEquals(0, optimizationModel.getOptimizedSolutionX().get("X[task__D][MainCPU] = ").intValue());
+        assertEquals(1, optimizationModel.getOptimizedSolutionX().get("X[task__D][dsp] = ").intValue());
+        assertEquals(1, optimizationModel.getOptimizedSolutionX().get("X[task__E][MainCPU] = ").intValue());
+        assertEquals(0, optimizationModel.getOptimizedSolutionX().get("X[task__E][dsp] = ").intValue());
 
-    assertEquals(0, optimizationModel.getOptimizedSolutionStart().get("start[task__A] = ").intValue());
-    assertEquals(300, optimizationModel.getOptimizedSolutionStart().get("start[task__B] = ").intValue());
-    assertEquals(400, optimizationModel.getOptimizedSolutionStart().get("start[task__D] = ").intValue());
-    assertEquals(500, optimizationModel.getOptimizedSolutionStart().get("start[task__E] = ").intValue());
+        assertEquals(0, optimizationModel.getOptimizedSolutionStart().get("start[task__A] = ").intValue());
+        assertEquals(300, optimizationModel.getOptimizedSolutionStart().get("start[task__B] = ").intValue());
+        assertEquals(400, optimizationModel.getOptimizedSolutionStart().get("start[task__D] = ").intValue());
+        assertEquals(500, optimizationModel.getOptimizedSolutionStart().get("start[task__E] = ").intValue());
 
-  }
+    }
 
 
-  @Test
-  public void findFeasibleMapping() {
-      String error = ConfigurationTTool.loadZ3Libs();
-      if (error != null) {
-          // we cannot run the test since Z3 is not installed
-          return;
-      }
-      OptimizationResult result = optimizationModel.findFeasibleMapping();
+    @Test
+    public void findFeasibleMapping() {
+        String error = ConfigurationTTool.loadZ3Libs();
+        if (error != null) {
+            // we cannot run the test since Z3 is not installed
+            return;
+        }
+        OptimizationResult result = optimizationModel.findFeasibleMapping();
 
-      Log.close();
+        Log.close();
 
 
+    }
 
-  }
 
+    @Test
+    public void getFeasibleCPUs() {
 
-  @Test
-  public void getFeasibleCPUs() {
+        Boolean test = false;
+        List<HwExecutionNode> expectedList = new ArrayList<>();
+        expectedList.add(inputInstance.getArchitecture().getHwCPUByName("MainCPU"));
+        expectedList.add(inputInstance.getArchitecture().getHwCPUByName("dsp"));
 
-    Boolean test = false;
-    List <HwExecutionNode> expectedList = new ArrayList<>();
-    expectedList.add(inputInstance.getArchitecture().getHwCPUByName("MainCPU"));
-    expectedList.add(inputInstance.getArchitecture().getHwCPUByName("dsp"));
+        TMLTask tempTask = inputInstance.getModeling().getTasks().get(2);
 
-    TMLTask tempTask =  inputInstance.getModeling().getTasks().get(2);
 
+        List<HwExecutionNode> actualList = new ArrayList<>();
 
-    List<HwExecutionNode> actualList = new ArrayList<>();
+        for (int i = 0; i < inputInstance.getFeasibleCPUs(tempTask).size(); i++) {
+            actualList.add(inputInstance.getFeasibleCPUs(tempTask).get(i));
+        }
 
-    for (int i = 0; i < inputInstance.getFeasibleCPUs(tempTask).size(); i++) {
-      actualList.add(inputInstance.getFeasibleCPUs(tempTask).get(i));
-    }
+        assertEquals(actualList.size(), expectedList.size());
 
-    assertEquals(actualList.size(), expectedList.size());
+        for (HwExecutionNode hwExecutionNode : actualList) {
+            assertTrue(expectedList.contains(hwExecutionNode));
+        }
 
-    for (HwExecutionNode hwExecutionNode : actualList){
-      assertTrue(expectedList.contains(hwExecutionNode));
     }
 
-  }
+    //  @Test
+    public void getBufferIn() {
+
+        List<TMLTask> tempTasks = new ArrayList<>();
+        for (int i = 0; i < inputInstance.getModeling().getTasks().size(); i++) {
+            tempTasks.add(inputInstance.getModeling().getTasks().get(i));
+        }
 
-//  @Test
-  public void getBufferIn() {
+        assertEquals(inputInstance.getBufferIn(tempTasks.get(0)), 0);
+        assertEquals(inputInstance.getBufferIn(tempTasks.get(1)), 2);
+        assertEquals(inputInstance.getBufferIn(tempTasks.get(2)), 2);
+        assertEquals(inputInstance.getBufferIn(tempTasks.get(3)), 10);
 
-    List<TMLTask> tempTasks = new ArrayList<>();
-    for (int i = 0; i < inputInstance.getModeling().getTasks().size(); i++) {
-      tempTasks.add( inputInstance.getModeling().getTasks().get(i));
-    }
 
-    assertEquals(inputInstance.getBufferIn( tempTasks.get(0)), 0);
-    assertEquals(inputInstance.getBufferIn( tempTasks.get(1)), 2);
-    assertEquals(inputInstance.getBufferIn( tempTasks.get(2)), 2);
-    assertEquals(inputInstance.getBufferIn(tempTasks.get(3)), 10);
+    }
 
+    // @Test
+    public void getBufferOut() {
+        List<TMLTask> tempTasks = new ArrayList<>();
+        for (int i = 0; i < inputInstance.getModeling().getTasks().size(); i++) {
+            tempTasks.add(inputInstance.getModeling().getTasks().get(i));
+        }
 
-  }
+        assertEquals(inputInstance.getBufferOut(tempTasks.get(0)), 4);
+        assertEquals(inputInstance.getBufferOut(tempTasks.get(1)), 5);
+        assertEquals(inputInstance.getBufferOut(tempTasks.get(2)), 5);
+        assertEquals(inputInstance.getBufferOut(tempTasks.get(3)), 0);
 
- // @Test
-  public void getBufferOut() {
-    List<TMLTask> tempTasks = new ArrayList<>();
-    for (int i = 0; i < inputInstance.getModeling().getTasks().size(); i++) {
-      tempTasks.add(inputInstance.getModeling().getTasks().get(i));
     }
 
-    assertEquals(inputInstance.getBufferOut( tempTasks.get(0)), 4);
-    assertEquals(inputInstance.getBufferOut( tempTasks.get(1)), 5);
-    assertEquals(inputInstance.getBufferOut( tempTasks.get(2)), 5);
-    assertEquals(inputInstance.getBufferOut( tempTasks.get(3)), 0);
 
-  }
+    @Test
+    public void getLocalMemoryOfHwExecutionNode() {
 
+        HwNode output1 = inputInstance.getArchitecture().getHwMemoryByName("mainMem");
+        HwNode output2 = inputInstance.getArchitecture().getHwMemoryByName("dspMem");
 
-  @Test
-  public void getLocalMemoryOfHwExecutionNode() {
+        assertTrue("comparing between the expected local memory for main_CPU and the memory found", inputInstance.getLocalMemoryOfHwExecutionNode(inputInstance.getArchitecture().getHwNodeByName("MainCPU")) == output1);
+        assertTrue("comparing between the expected local memory for DSP and the memory found", inputInstance.getLocalMemoryOfHwExecutionNode(inputInstance.getArchitecture().getHwNodeByName("dsp")) == output2);
 
-    HwNode output1 = inputInstance.getArchitecture().getHwMemoryByName("mainMem");
-    HwNode output2 = inputInstance.getArchitecture().getHwMemoryByName("dspMem");
+    }
 
-    assertTrue("comparing between the expected local memory for main_CPU and the memory found", inputInstance.getLocalMemoryOfHwExecutionNode(inputInstance.getArchitecture().getHwNodeByName("MainCPU")) == output1);
-    assertTrue("comparing between the expected local memory for DSP and the memory found", inputInstance.getLocalMemoryOfHwExecutionNode(inputInstance.getArchitecture().getHwNodeByName("dsp")) == output2);
 
-  }
+    @Test
+    public void getWCET() {
+        //a temporary list of the tasks
+        List<TMLTask> tempTasks = new ArrayList<>();
+        for (int i = 0; i < inputInstance.getModeling().getTasks().size(); i++) {
+            tempTasks.add(inputInstance.getModeling().getTasks().get(i));
+        }
+        int expectedWcetA_CPU = 300;
+        int expectedWcetA_dsp = 150;
 
+        assertEquals("comparing between the expected WCET of task A on main_CPU and the computed value", expectedWcetA_CPU, inputInstance.getWCET(tempTasks.get(0), (HwExecutionNode) inputInstance.getArchitecture().getHwNodeByName("MainCPU")));
+        assertEquals("comparing between the expected WCET of task A on DSP and the computed value", expectedWcetA_dsp, inputInstance.getWCET(tempTasks.get(0), (HwExecutionNode) inputInstance.getArchitecture().getHwNodeByName("dsp")));
 
-  @Test
-  public void getWCET() {
-    //a temporary list of the tasks
-    List<TMLTask> tempTasks = new ArrayList<>();
-    for (int i = 0; i < inputInstance.getModeling().getTasks().size(); i++) {
-      tempTasks.add( inputInstance.getModeling().getTasks().get(i));
     }
-    int expectedWcetA_CPU = 300;
-    int expectedWcetA_dsp = 150;
 
-    assertEquals("comparing between the expected WCET of task A on main_CPU and the computed value", expectedWcetA_CPU, inputInstance.getWCET(tempTasks.get(0), (HwExecutionNode) inputInstance.getArchitecture().getHwNodeByName("MainCPU")));
-    assertEquals("comparing between the expected WCET of task A on DSP and the computed value", expectedWcetA_dsp, inputInstance.getWCET(tempTasks.get(0), (HwExecutionNode) inputInstance.getArchitecture().getHwNodeByName("dsp")));
 
-  }
+    @Test
+    public void getFinalTask() {
+        assertEquals("checking the last task", inputInstance.getModeling().getTMLTaskByName("task__E"), inputInstance.getFinalTask(inputInstance.getModeling()));
 
-
-  @Test
-  public void getFinalTask() {
-    assertEquals("checking the last task", inputInstance.getModeling().getTMLTaskByName("task__E"), inputInstance.getFinalTask(inputInstance.getModeling()));
-
-  }
+    }
 }