Skip to content
Snippets Groups Projects
Commit bf412398 authored by maysam zoor's avatar maysam zoor
Browse files

remove file

parent 8ec9e902
Branches
No related tags found
1 merge request!402Plan test
Hide whitespace changes
Inline Side-by-side
ttool/src/test/java/ui/GraphLatencyAnalysis/CompareLatencyInSimulationTracesTest.java deleted 100644 → 0
+ 0
− 162
View file @ 8ec9e902
package ui.GraphLatencyAnalysis;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Vector;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPathExpressionException;
import org.junit.Before;
import org.junit.Test;
import org.xml.sax.SAXException;
import tmltranslator.simulation.DependencyGraphTranslator;
import tmltranslator.simulation.SimulationTransaction;
import ui.AbstractUITest;
import ui.SimulationTrace;
import ui.TMLArchiPanel;
import ui.simulationtraceanalysis.JFrameCompareLatencyDetail;
import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
import ui.simulationtraceanalysis.LatencyAnalysisParallelAlgorithms;
import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
public class CompareLatencyInSimulationTracesTest extends AbstractUITest {
private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
private static final String simulationTracePathFile1 = INPUT_PATH + "/graphTestSimulationTrace.xml";
private static final String simulationTracePathFile2 = INPUT_PATH + "/testFunc.xml";
private static final String modelPath = INPUT_PATH + "/GraphTestModel.xml";
private static final String mappingDiagName = "Architecture2";
private Vector<String> checkedTransactionsFile1 = new Vector<String>();
private Vector<String> checkedTransactionsFile2 = new Vector<String>();
private static final int operator1ID = 44;
private static final int operator2ID = 26;
private static final int operator3ID = 40;
private static final int operator4ID = 28;
private DependencyGraphTranslator dgraph1, dgraph2;
private static String task1, task2, task3, task4;
private JFrameCompareLatencyDetail cld;
private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
private JFrameLatencyDetailedAnalysis jFrameLatencyDetailedAnalysis;
private Vector<SimulationTransaction> transFile1, transFile2;
private SimulationTrace simT1, simT2;
private File file1, file2;
private int row, row2;
private HashMap<String, Integer> checkedT1 = new HashMap<String, Integer>();
private HashMap<String, Integer> checkedT2 = new HashMap<String, Integer>();
// protected MainGUI mainGUI1 = null;
private static Object[][] dataDetailedByTask, dataDetailedByTask2, dataHWDelayByTask, dataHWDelayByTask2;
public CompareLatencyInSimulationTracesTest() {
super();
}
@Before
public void GraphLatencyAnalysis()
throws XPathExpressionException, ParserConfigurationException, SAXException, IOException, InterruptedException {
mainGUI.openProjectFromFile(new File(getBaseResourcesDir() + modelPath));
final TMLArchiPanel panel = findArchiPanel(mappingDiagName);
simT1 = new SimulationTrace("graphTestSimulationTrace", 6, (getBaseResourcesDir() + simulationTracePathFile1));
LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(3, mainGUI, simT1, false, false, 3);
LatencyDetailedAnalysisMain.setCheckedTransactionsFile(new Vector<String>());
try {
LatencyDetailedAnalysisMain.latencyDetailedAnalysisForXML(mainGUI, simT1, false, true, 1);
LatencyDetailedAnalysisMain.setTc(new LatencyAnalysisParallelAlgorithms(LatencyDetailedAnalysisMain));
cld = new JFrameCompareLatencyDetail(LatencyDetailedAnalysisMain, mainGUI, checkedTransactionsFile1,
LatencyDetailedAnalysisMain.getMap1(), LatencyDetailedAnalysisMain.getCpanels1(), simT1, false,
LatencyDetailedAnalysisMain.getTc());
if (cld == null) {
System.out.println("NULL Panel");
} else {
cld.setVisible(false);
}
} catch (XPathExpressionException | ParserConfigurationException | SAXException | IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
LatencyDetailedAnalysisMain.getTc().getT().join();
if (cld.getDgraph().getGraphsize() > 0) {
dgraph1 = cld.getDgraph();
checkedTransactionsFile1 = LatencyDetailedAnalysisMain.getCheckedTransactionsFile();
checkedT1 = LatencyDetailedAnalysisMain.getCheckedT1();
cld.setDgraph(null);
LatencyDetailedAnalysisMain.setCheckedTransactionsFile(new Vector<String>());
simT2 = new SimulationTrace("graphTestSimulationTrace", 6, (getBaseResourcesDir() + simulationTracePathFile2));
try {
LatencyDetailedAnalysisMain.latencyDetailedAnalysisForXML(mainGUI, simT2, false, true, 1);
} catch (XPathExpressionException | ParserConfigurationException | SAXException | IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
dgraph2 = new DependencyGraphTranslator(LatencyDetailedAnalysisMain.getMap1());
dgraph2.DrawDirectedGraph();
checkedTransactionsFile2 = LatencyDetailedAnalysisMain.getCheckedTransactionsFile();
checkedT2 = LatencyDetailedAnalysisMain.getCheckedT2();
}
}
@Test
public void parseFile() {
int graphsize = dgraph1.getGraphsize();
assertTrue(1 > 0);
graphsize = dgraph2.getGraphsize();
assertTrue(graphsize > 0);
assertTrue(checkedT1.size() == 3);
assertTrue(checkedT2.size() == 3);
for (Entry<String, Integer> cT : checkedT1.entrySet()) {
int id = cT.getValue();
String taskName = cT.getKey();
if (id == operator1ID) {
task1 = taskName;
} else if (id == operator2ID) {
task2 = taskName;
}
}
for (Entry<String, Integer> cT : checkedT2.entrySet()) {
int id = cT.getValue();
String taskName = cT.getKey();
if (id == operator3ID) {
task3 = taskName;
} else if (id == operator4ID) {
task4 = taskName;
}
}
file1 = new File(simT1.getFullPath());
file2 = new File(simT2.getFullPath());
transFile1 = cld.parseFile(file1);
transFile2 = cld.parseFile(file2);
cld.setDgraph2(dgraph2);
cld.latencyDetailedAnalysis(task1, task2, task3, task4, transFile1, transFile2, false, false, false);
cld.setVisible(false);
assertTrue(cld.getTableData().length > 0);
assertTrue(cld.getTableData2().length > 0);
assertTrue(cld.getTableData1MinMax().length > 0);
assertTrue(cld.getTableData2MinMax().length > 0);
// test row 1 table 1 and row 1 table 2
row = 1;
row2 = 1;
dataDetailedByTask = dgraph1.getTaskByRowDetails(row);
dataDetailedByTask2 = dgraph2.getTaskByRowDetails(row2);
dataHWDelayByTask = dgraph1.getTaskHWByRowDetails(row);
dataHWDelayByTask2 = dgraph2.getTaskHWByRowDetails(row2);
assertTrue(dataDetailedByTask.length > 0);
assertTrue(dataDetailedByTask2.length > 0);
assertTrue(dataHWDelayByTask.length > 0);
assertTrue(dataHWDelayByTask2.length > 0);
// test max table 1 and max table 2
dgraph1.getRowDetailsMinMax(row);
dataDetailedByTask = dgraph1.getTasksByRowMinMax(row);
dgraph2.getRowDetailsMinMax(row2);
dataDetailedByTask2 = dgraph2.getTasksByRowMinMax(row2);
dataHWDelayByTask = dgraph1.getTaskHWByRowDetailsMinMax(row);
dataHWDelayByTask2 = dgraph2.getTaskHWByRowDetailsMinMax(row2);
assertTrue(dataDetailedByTask.length > 0);
assertTrue(dataDetailedByTask2.length > 0);
assertTrue(dataHWDelayByTask.length > 0);
assertTrue(dataHWDelayByTask2.length > 0);
}
}
\ No newline at end of file
ttool/src/test/java/ui/GraphLatencyAnalysis/NestedStructurePLANTest.java deleted 100644 → 0
+ 0
− 164
View file @ 8ec9e902
package ui.GraphLatencyAnalysis;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.awt.*;
import java.io.File;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Vector;
import org.junit.Before;
import org.junit.Test;
import tmltranslator.simulation.DependencyGraphTranslator;
import tmltranslator.simulation.SimulationTransaction;
import ui.AbstractUITest;
import ui.SimulationTrace;
import ui.TMLArchiPanel;
import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
public class NestedStructurePLANTest extends AbstractUITest {
private static final int[] EXIST_EDGE = {66, 65,
66,63,
64, 63};
private static final String mapping_Diag_Name = "Architecture";
private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
private static final String SIMULATIONTRACE_PATH_FILE = INPUT_PATH + "/loopseqTrace.xml";
private static final String MODEL_PATH = INPUT_PATH + "/loopseqgraph.xml";
private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
private JFrameLatencyDetailedAnalysis latencyDetailedAnalysis;
private static DependencyGraphTranslator dgt;
private Vector<SimulationTransaction> transFile1;
private HashMap<String, Integer> checkedDropDown = new HashMap<String, Integer>();
private static final int OPERATOR1_ID = 69;
private static final int OPERATOR2_ID = 53;
private static String task1;
private static String task2;
private static Object[][] allLatencies;
@Before
public void NestedStructurePLAN() throws InterruptedException {
mainGUI.openProjectFromFile(new File(getBaseResourcesDir() + MODEL_PATH));
// mainGUI.openProjectFromFile(new File(modelPath));
final TMLArchiPanel panel = findArchiPanel(mapping_Diag_Name);
if (panel == null) {
System.out.println("NULL Panel");
} else {
System.out.println("Non NULL Panel");
}
mainGUI.checkModelingSyntax(panel, true);
SimulationTrace file2 = new SimulationTrace("graphTestSimulationTrace", 6, SIMULATIONTRACE_PATH_FILE);
LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(3, mainGUI, file2, false, false, 3);
LatencyDetailedAnalysisMain.getTc().setMainGUI(mainGUI);
LatencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mainGUI);
latencyDetailedAnalysis = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
if (latencyDetailedAnalysis != null) {
latencyDetailedAnalysis.setVisible(false);
latencyDetailedAnalysis.getTc().run();
try {
latencyDetailedAnalysis.getT().join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
dgt = latencyDetailedAnalysis.getDgraph();
}
}
@Test
public void parseFile() {
assertNotNull(latencyDetailedAnalysis);
int graphsize = dgt.getGraphsize();
System.out.println("Graphsize=" + graphsize);
assertTrue(graphsize >= 57);
// test sequence to all its nexts
for(int i=0; i<EXIST_EDGE.length-1; i = i + 2) {
assertTrue(dgt.edgeExists(EXIST_EDGE[i], EXIST_EDGE[i+1]));
}
/*assertTrue(dgt.edgeExists(66, 65));
assertTrue(dgt.edgeExists(66, 63));
// test sequence branch to another
assertTrue(dgt.edgeExists(64, 63));*/
assertTrue(dgt.edgeExists(63, 62));
// test ordered sequence
assertTrue(dgt.edgeExists(62, 61));
assertTrue(dgt.edgeExists(62, 60));
// test nested sequence to unordered sequence
assertTrue(dgt.edgeExists(57, 60));
assertTrue(dgt.edgeExists(68, 60));
// test unordered sequence nexts
assertTrue(dgt.edgeExists(61, 67));
assertTrue(dgt.edgeExists(61, 58));
assertTrue(dgt.edgeExists(68, 58));
assertTrue(dgt.edgeExists(57, 67));
// test ordered sequence nexts
assertTrue(dgt.edgeExists(26, 25));
assertTrue(dgt.edgeExists(26, 21));
assertTrue(dgt.edgeExists(26, 23));
// test ordered sequence ends
assertTrue(dgt.edgeExists(24, 21));
// nested seq loop
assertTrue(dgt.edgeExists(27, 23));
assertTrue(dgt.edgeExists(30, 36));
assertTrue(dgt.edgeExists(29, 36));
// inside loop only connected to loop vertex
assertFalse(dgt.edgeExists(30, 22));
assertFalse(dgt.edgeExists(29, 22));
// sequence last branch end not connected to other branches
assertFalse(dgt.edgeExists(22, 25));
assertFalse(dgt.edgeExists(22, 21));
// sequence branches not connected backward
assertFalse(dgt.edgeExists(27, 25));
// loop for ever edges+ nested loops and seq
assertTrue(dgt.edgeExists(44, 49));
assertTrue(dgt.edgeExists(44, 51));
assertTrue(dgt.edgeExists(44, 53));
assertTrue(dgt.edgeExists(43, 42));
assertTrue(dgt.edgeExists(43, 41));
assertTrue(dgt.edgeExists(45, 41));
assertTrue(dgt.edgeExists(40, 49));
assertTrue(dgt.edgeExists(48, 54));
assertTrue(dgt.edgeExists(48, 51));
assertTrue(dgt.edgeExists(48, 53));
assertTrue(dgt.edgeExists(50, 49));
assertTrue(dgt.edgeExists(50, 53));
assertTrue(dgt.edgeExists(50, 54));
assertTrue(dgt.edgeExists(52, 51));
assertTrue(dgt.edgeExists(52, 49));
assertTrue(dgt.edgeExists(52, 54));
assertFalse(dgt.edgeExists(40, 54));
assertFalse(dgt.edgeExists(40, 42));
transFile1 = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(getBaseResourcesDir() + SIMULATIONTRACE_PATH_FILE));
assertTrue(transFile1.size() == 38);
checkedDropDown = latencyDetailedAnalysis.getCheckedT();
for (Entry<String, Integer> cT : checkedDropDown.entrySet()) {
int id = cT.getValue();
String taskName = cT.getKey();
if (id == OPERATOR1_ID) {
task1 = taskName;
} else if (id == OPERATOR2_ID) {
task2 = taskName;
}
}
allLatencies = dgt.latencyDetailedAnalysis(task1, task2, transFile1, false, false);
assertTrue(allLatencies.length == 1);
assertTrue((int) allLatencies[0][1] == 60);
assertTrue((int) allLatencies[0][3] == 212);
assertTrue((int) allLatencies[0][4] == 152);
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment