/*******************************************************************************
- * Copyright (c) 2011 Ericsson
+ * Copyright (c) 2011, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Mathieu Denis <mathieu.denis@polymtl.ca> - Initial design and implementation
* Bernd Hufmann - Fixed warnings
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.ui.tests.statistics;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.util.Collection;
import java.util.Iterator;
import java.util.Vector;
-import junit.framework.TestCase;
-
-import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.util.TmfFixedArray;
-import org.eclipse.linuxtools.tmf.ui.viewers.statistics.ITmfExtraEventInfo;
-import org.eclipse.linuxtools.tmf.ui.viewers.statistics.model.AbsTmfStatisticsTree;
import org.eclipse.linuxtools.tmf.ui.viewers.statistics.model.Messages;
-import org.eclipse.linuxtools.tmf.ui.viewers.statistics.model.TmfBaseStatisticsTree;
+import org.eclipse.linuxtools.tmf.ui.viewers.statistics.model.TmfStatisticsTree;
import org.eclipse.linuxtools.tmf.ui.viewers.statistics.model.TmfStatisticsTreeNode;
+import org.junit.Test;
/**
* TmfStatisticsTreeNode Test Cases.
*/
-@SuppressWarnings("nls")
-public class TmfStatisticsTreeNodeTest extends TestCase {
+public class TmfStatisticsTreeNodeTest {
// ------------------------------------------------------------------------
// Fields
// ------------------------------------------------------------------------
- private String fTestName = null;
-
- private final String fContext = "UnitTest";
private final String fTypeId1 = "Some type1";
private final String fTypeId2 = "Some type2";
+ private final String fTypeId3 = "Some type3";
- private final String fLabel0 = "label1";
- private final String fLabel1 = "label2";
- private final String fLabel2 = "label3";
- private final String[] fLabels = new String[] { fLabel0, fLabel1, fLabel2 };
-
- private final TmfTimestamp fTimestamp1 = new TmfTimestamp(12345, (byte) 2, 5);
- private final TmfTimestamp fTimestamp2 = new TmfTimestamp(12350, (byte) 2, 5);
- private final TmfTimestamp fTimestamp3 = new TmfTimestamp(12355, (byte) 2, 5);
-
- private final String fSource = "Source";
-
- private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId1, TmfEventField.makeRoot(fLabels));
- private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId2, TmfEventField.makeRoot(fLabels));
+ private final TmfStatisticsTree fStatsTree;
- private final String fReference = "Some reference";
-
- private final TmfEvent fEvent1;
- private final TmfEvent fEvent2;
- private final TmfEvent fEvent3;
-
- private final TmfEventField fContent1;
- private final TmfEventField fContent2;
- private final TmfEventField fContent3;
-
- private final TmfBaseStatisticsTree fStatsData;
-
- private final ITmfExtraEventInfo fExtraInfo;
+ private static final String fTestName = "StatisticsTreeNodeTest";
// ------------------------------------------------------------------------
// Housekeeping
// ------------------------------------------------------------------------
/**
- * @param name
- * Test name
+ * Constructor
*/
- public TmfStatisticsTreeNodeTest(final String name) {
- super(name);
-
- fTestName = name;
-
- fContent1 = new TmfEventField(ITmfEventField.ROOT_FIELD_ID, "Some content");
- fEvent1 = new TmfEvent(null, fTimestamp1, fSource, fType1, fContent1, fReference);
-
- fContent2 = new TmfEventField(ITmfEventField.ROOT_FIELD_ID, "Some other content");
- fEvent2 = new TmfEvent(null, fTimestamp2, fSource, fType1, fContent2, fReference);
-
- fContent3 = new TmfEventField(ITmfEventField.ROOT_FIELD_ID, "Some other different content");
- fEvent3 = new TmfEvent(null, fTimestamp3, fSource, fType2, fContent3, fReference);
-
- fStatsData = new TmfBaseStatisticsTree();
- fExtraInfo = new ITmfExtraEventInfo() {
- @Override
- public String getTraceName() {
- return fTestName;
- }
- };
- fStatsData.registerEvent(fEvent1, fExtraInfo);
- fStatsData.registerEvent(fEvent1, fExtraInfo, 2);
- fStatsData.registerEvent(fEvent2, fExtraInfo);
- fStatsData.registerEvent(fEvent2, fExtraInfo, 3);
- fStatsData.registerEvent(fEvent3, fExtraInfo);
- fStatsData.registerEvent(fEvent3, fExtraInfo, 4);
-
- // Registers some events in time range
- fStatsData.registerEventInTimeRange(fEvent1, fExtraInfo);
- fStatsData.registerEventInTimeRange(fEvent1, fExtraInfo, 3);
- fStatsData.registerEventInTimeRange(fEvent2, fExtraInfo);
- fStatsData.registerEventInTimeRange(fEvent2, fExtraInfo, 4);
- fStatsData.registerEventInTimeRange(fEvent3, fExtraInfo);
- fStatsData.registerEventInTimeRange(fEvent3, fExtraInfo, 5);
+ public TmfStatisticsTreeNodeTest() {
+ fStatsTree = new TmfStatisticsTree();
+
+ /* Enter some global values */
+ fStatsTree.setTotal(fTestName, true, 18);
+ fStatsTree.setTypeCount(fTestName, fTypeId1, true, 5);
+ fStatsTree.setTypeCount(fTestName, fTypeId2, true, 6);
+ fStatsTree.setTypeCount(fTestName, fTypeId3, true, 7);
+
+ /* Enter some time range values */
+ fStatsTree.setTotal(fTestName, false, 9);
+ fStatsTree.setTypeCount(fTestName, fTypeId1, false, 2);
+ fStatsTree.setTypeCount(fTestName, fTypeId2, false, 3);
+ fStatsTree.setTypeCount(fTestName, fTypeId3, false, 4);
}
- // ------------------------------------------------------------------------
- // ContainsChild
- // ------------------------------------------------------------------------
-
/**
* Test checking for child.
*/
+ @Test
public void testContainsChild() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
+ TmfStatisticsTreeNode rootNode = fStatsTree.getRootNode();
+ TmfStatisticsTreeNode traceNode = fStatsTree.getNode(fTestName);
// Creates a category from the key already created
TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next();
- assertTrue("containsChild", rootNode.containsChild(fTestName));
- assertFalse("containsChild", rootNode.containsChild(catNode.getKey()));
- assertFalse("containsChild", rootNode.containsChild(null));
+ assertTrue(rootNode.containsChild(fTestName));
+ assertFalse(rootNode.containsChild(catNode.getName()));
+ assertFalse(rootNode.containsChild(null));
- assertTrue("containsChild", traceNode.containsChild(catNode.getKey()));
- assertFalse("containsChild", traceNode.containsChild(fType1.getName()));
- assertFalse("containsChild", traceNode.containsChild(null));
+ assertTrue(traceNode.containsChild(catNode.getName()));
+ assertFalse(traceNode.containsChild(fTypeId1));
+ assertFalse(traceNode.containsChild(null));
- assertTrue("containsChild", catNode.containsChild(fType1.getName()));
- assertTrue("containsChild", catNode.containsChild(fType2.getName()));
- assertFalse("containsChild", catNode.containsChild(null));
+ assertTrue(catNode.containsChild(fTypeId1));
+ assertTrue(catNode.containsChild(fTypeId2));
+ assertFalse(catNode.containsChild(null));
}
- // ------------------------------------------------------------------------
- // GetChildren
- // ------------------------------------------------------------------------
-
/**
* Test getting of children.
*/
+ @Test
public void testGetChildren() {
// Getting children of the ROOT
- Collection<TmfStatisticsTreeNode> childrenTreeNode = fStatsData.get(AbsTmfStatisticsTree.ROOT).getChildren();
- assertEquals("getChildren", 1, childrenTreeNode.size());
+ Collection<TmfStatisticsTreeNode> childrenTreeNode = fStatsTree.getRootNode().getChildren();
+ assertEquals(1, childrenTreeNode.size());
TmfStatisticsTreeNode treeNode = childrenTreeNode.iterator().next();
- assertEquals("getChildren", fTestName, treeNode.getKey());
+ assertEquals(fTestName, treeNode.getName());
// Getting children of the trace
- childrenTreeNode = fStatsData.get(new TmfFixedArray<String>(fTestName)).getChildren();
- assertEquals("getChildren", 1, childrenTreeNode.size());
+ childrenTreeNode = fStatsTree.getNode(fTestName).getChildren();
+ assertEquals(1, childrenTreeNode.size());
treeNode = childrenTreeNode.iterator().next();
- assertEquals("getChildren", Messages.TmfStatisticsData_EventTypes, treeNode.getKey());
+ assertEquals(Messages.TmfStatisticsData_EventTypes, treeNode.getName());
Vector<String> keyExpected = new Vector<String>();
- keyExpected.add(fType1.getName());
- keyExpected.add(fType2.getName());
+ keyExpected.add(fTypeId1);
+ keyExpected.add(fTypeId2);
+ keyExpected.add(fTypeId3);
// Getting children of a category
childrenTreeNode = treeNode.getChildren();
- assertEquals("getChildren", 2, childrenTreeNode.size());
+ assertEquals(3, childrenTreeNode.size());
Iterator<TmfStatisticsTreeNode> iterChild = childrenTreeNode.iterator();
TmfStatisticsTreeNode temp;
while (iterChild.hasNext()) {
temp = iterChild.next();
- if (keyExpected.contains(temp.getKey())) {
- keyExpected.removeElement(temp.getKey());
+ if (keyExpected.contains(temp.getName())) {
+ keyExpected.removeElement(temp.getName());
} else {
fail();
}
}
// Get children of a specific event type
- childrenTreeNode = fStatsData.get(childrenTreeNode.iterator().next().getPath()).getChildren();
- assertEquals("getChildren", 0, childrenTreeNode.size());
+ childrenTreeNode = fStatsTree.getNode(childrenTreeNode.iterator().next().getPath()).getChildren();
+ assertEquals(0, childrenTreeNode.size());
}
- // ------------------------------------------------------------------------
- // GetAllChildren
- // ------------------------------------------------------------------------
-
- /**
- * Test getting of all children.
- */
- public void testGetAllChildren() {
- // Getting children of the ROOT
- Collection<TmfStatisticsTreeNode> childrenTreeNode = fStatsData.get(AbsTmfStatisticsTree.ROOT).getAllChildren();
- assertEquals("getChildren", 1, childrenTreeNode.size());
- TmfStatisticsTreeNode treeNode = childrenTreeNode.iterator().next();
- assertEquals("getChildren", fTestName, treeNode.getKey());
-
- // Getting children of the trace
- childrenTreeNode = fStatsData.get(new TmfFixedArray<String>(fTestName)).getAllChildren();
- assertEquals("getChildren", 1, childrenTreeNode.size());
- treeNode = childrenTreeNode.iterator().next();
- assertEquals("getChildren", Messages.TmfStatisticsData_EventTypes, treeNode.getKey());
-
- Vector<String> keyExpected = new Vector<String>();
- keyExpected.add(fType1.getName());
- keyExpected.add(fType2.getName());
- /*
- * It should return the eventType even though the number of events
- * equals 0
- */
- fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName())).reset();
- // Getting children of a category
- childrenTreeNode = treeNode.getAllChildren();
- assertEquals("getChildren", 2, childrenTreeNode.size());
-
- Iterator<TmfStatisticsTreeNode> iterChild = childrenTreeNode.iterator();
- TmfStatisticsTreeNode temp;
- while (iterChild.hasNext()) {
- temp = iterChild.next();
- if (keyExpected.contains(temp.getKey())) {
- keyExpected.removeElement(temp.getKey());
- } else {
- fail();
- }
- }
-
- // Get children of a specific event type
- childrenTreeNode = fStatsData.get(childrenTreeNode.iterator().next().getPath()).getAllChildren();
- assertEquals("getChildren", 0, childrenTreeNode.size());
- }
-
- // ------------------------------------------------------------------------
- // GetNbChildren
- // ------------------------------------------------------------------------
-
/**
* Test getting of number of children.
*/
+ @Test
public void testGetNbChildren() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
+ TmfStatisticsTreeNode rootNode = fStatsTree.getRootNode();
+ TmfStatisticsTreeNode traceNode = fStatsTree.getNode(fTestName);
TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next();
- TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName()));
+ TmfStatisticsTreeNode elementNode = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
- assertEquals("getNbChildren", 1, rootNode.getNbChildren());
- assertEquals("getNbChildren", 1, traceNode.getNbChildren());
- assertEquals("getNbChildren", 2, catNode.getNbChildren());
- assertEquals("getNbChildren", 0, elementNode.getNbChildren());
+ assertEquals(1, rootNode.getNbChildren());
+ assertEquals(1, traceNode.getNbChildren());
+ assertEquals(3, catNode.getNbChildren());
+ assertEquals(0, elementNode.getNbChildren());
}
- // ------------------------------------------------------------------------
- // HasChildren
- // ------------------------------------------------------------------------
-
/**
* Test checking for children.
*/
+ @Test
public void testHasChildren() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
+ TmfStatisticsTreeNode rootNode = fStatsTree.getRootNode();
+ TmfStatisticsTreeNode traceNode = fStatsTree.getNode(fTestName);
TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next();
- TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName()));
+ TmfStatisticsTreeNode elementNode = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
- assertTrue("hasChildren", rootNode.hasChildren());
- assertTrue("hasChildren", traceNode.hasChildren());
- assertTrue("hasChildren", catNode.hasChildren());
- assertFalse("hasChildren", elementNode.hasChildren());
+ assertTrue(rootNode.hasChildren());
+ assertTrue(traceNode.hasChildren());
+ assertTrue(catNode.hasChildren());
+ assertFalse(elementNode.hasChildren());
}
- // ------------------------------------------------------------------------
- // GetParent
- // ------------------------------------------------------------------------
-
/**
* Test getting of parent.
*/
+ @Test
public void testGetParent() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
+ final TmfStatisticsTreeNode rootNode = fStatsTree.getRootNode();
TmfStatisticsTreeNode parentNode = rootNode.getParent();
- assertNull("getParent", parentNode);
+ assertNull(parentNode);
- TmfStatisticsTreeNode newTraceNode = new TmfStatisticsTreeNode(new TmfFixedArray<String>("newly created trace node"), fStatsData);
+ TmfStatisticsTreeNode newTraceNode = new TmfStatisticsTreeNode(fStatsTree, rootNode, "newly created trace node");
parentNode = newTraceNode.getParent();
- assertNotNull("getParent", parentNode);
- assertEquals("getParent", 0, parentNode.getKey().compareTo(fStatsData.get(AbsTmfStatisticsTree.ROOT).getKey().toString()));
+ assertNotNull(parentNode);
+ assertTrue(fStatsTree.getRootNode() == parentNode);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
+ TmfStatisticsTreeNode traceNode = fStatsTree.getNode(fTestName);
parentNode = traceNode.getParent();
- assertNotNull("getParent", parentNode);
- assertEquals("getParent", 0, parentNode.getPath().toString().compareTo(AbsTmfStatisticsTree.ROOT.toString()));
-
- TmfStatisticsTreeNode newNode = new TmfStatisticsTreeNode(new TmfFixedArray<String>("TreeNode", Messages.TmfStatisticsData_EventTypes, "TreeNode that should not exist"), fStatsData);
- parentNode = newNode.getParent();
- assertNull("getParent", parentNode);
+ assertNotNull(parentNode);
+ assertTrue(rootNode == parentNode);
- TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName()));
+ TmfStatisticsTreeNode elementNode = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
parentNode = elementNode.getParent();
- assertNull("getParent", parentNode);
+ assertTrue(parentNode == fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes));
TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next();
parentNode = catNode.getParent();
- assertNotNull("getParent", parentNode);
- assertEquals("getParent", 0, parentNode.getPath().toString().compareTo(fStatsData.get(new TmfFixedArray<String>(fTestName)).getPath().toString()));
+ assertNotNull(parentNode);
+ assertTrue(parentNode == fStatsTree.getNode(fTestName));
parentNode = elementNode.getParent();
- assertNotNull("getParent", parentNode);
- assertTrue("getParent", parentNode.getPath().equals(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes)));
+ assertNotNull(parentNode);
+ assertTrue(arraysEqual(parentNode.getPath(), fTestName, Messages.TmfStatisticsData_EventTypes));
}
- // ------------------------------------------------------------------------
- // GetKey
- // ------------------------------------------------------------------------
-
/**
* Test getting of key.
*/
- public void testGetKey() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
+ @Test
+ public void testgetName() {
+ TmfStatisticsTreeNode rootNode = fStatsTree.getRootNode();
+ TmfStatisticsTreeNode traceNode = fStatsTree.getNode(fTestName);
TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next();
- TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName()));
+ TmfStatisticsTreeNode elementNode = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
- assertEquals("getKey", 0, rootNode.getKey().compareTo(AbsTmfStatisticsTree.ROOT.get(0)));
- assertEquals("getKey", 0, traceNode.getKey().compareTo(fTestName));
- assertEquals("getKey", 0, catNode.getKey().compareTo(Messages.TmfStatisticsData_EventTypes));
- assertEquals("getKey", 0, elementNode.getKey().compareTo(fType1.getName()));
+ assertEquals(0, rootNode.getName().compareTo("root"));
+ assertEquals(0, traceNode.getName().compareTo(fTestName));
+ assertEquals(0, catNode.getName().compareTo(Messages.TmfStatisticsData_EventTypes));
+ assertEquals(0, elementNode.getName().compareTo(fTypeId1));
}
- // ------------------------------------------------------------------------
- // GetPath
- // ------------------------------------------------------------------------
-
/**
* Test getting of path to node.
*/
+ @Test
public void testGetPath() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
+ TmfStatisticsTreeNode rootNode = fStatsTree.getRootNode();
+ TmfStatisticsTreeNode traceNode = fStatsTree.getNode(fTestName);
TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next();
- TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName()));
-
- assertTrue("getPath", rootNode.getPath().equals(AbsTmfStatisticsTree.ROOT));
- assertTrue("getPath", traceNode.getPath().equals(new TmfFixedArray<String>(fTestName)));
- assertTrue("getPath", catNode.getPath().equals(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes)));
- assertTrue("getPath", elementNode.getPath().equals(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName())));
+ TmfStatisticsTreeNode elementNode = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
+
+ assertEquals(0, rootNode.getPath().length); /* Root node has an empty path */
+ assertTrue(arraysEqual(traceNode.getPath(), fTestName));
+ assertTrue(arraysEqual(catNode.getPath(),
+ fTestName, Messages.TmfStatisticsData_EventTypes));
+ assertTrue(arraysEqual(elementNode.getPath(),
+ fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1));
}
- // ------------------------------------------------------------------------
- // GetValue
- // ------------------------------------------------------------------------
-
/**
* Test getting statistic value.
*/
+ @Test
public void testGetValue() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
- TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next();
- TmfStatisticsTreeNode elementNode1 = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName()));
- TmfStatisticsTreeNode elementNode3 = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType2.getName()));
-
- assertEquals("getValue", 0, rootNode.getValue().getTotal());
- assertEquals("getValue", 12, traceNode.getValue().getTotal());
- assertEquals("getValue", 0, catNode.getValue().getTotal());
- assertEquals("getValue", 7, elementNode1.getValue().getTotal());
- assertEquals("getValue", 5, elementNode3.getValue().getTotal());
-
- assertEquals("getValue", 0, rootNode.getValue().getPartial());
- assertEquals("getValue", 15, traceNode.getValue().getPartial());
- assertEquals("getValue", 0, catNode.getValue().getPartial());
- assertEquals("getValue", 9, elementNode1.getValue().getPartial());
- assertEquals("getValue", 6, elementNode3.getValue().getPartial());
+ TmfStatisticsTreeNode rootNode, traceNode, catNode, elementNode1, elementNode2, elementNode3;
+ rootNode = fStatsTree.getRootNode();
+ traceNode = fStatsTree.getNode(fTestName);
+ catNode = traceNode.getChildren().iterator().next();
+ elementNode1 = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
+ elementNode2 = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId2);
+ elementNode3 = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId3);
+
+ assertEquals(0, rootNode.getValues().getTotal());
+ assertEquals(18, traceNode.getValues().getTotal());
+ assertEquals(0, catNode.getValues().getTotal());
+ assertEquals(5, elementNode1.getValues().getTotal());
+ assertEquals(6, elementNode2.getValues().getTotal());
+ assertEquals(7, elementNode3.getValues().getTotal());
+
+ assertEquals(0, rootNode.getValues().getPartial());
+ assertEquals(9, traceNode.getValues().getPartial());
+ assertEquals(0, catNode.getValues().getPartial());
+ assertEquals(2, elementNode1.getValues().getPartial());
+ assertEquals(3, elementNode2.getValues().getPartial());
+ assertEquals(4, elementNode3.getValues().getPartial());
}
- // ------------------------------------------------------------------------
- // Reset
- // ------------------------------------------------------------------------
-
/**
* Test reset of tree.
*/
+ @Test
public void testReset() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
- TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next();
- TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName()));
+ TmfStatisticsTreeNode rootNode, traceNode, catNode, elementNode;
+ rootNode = fStatsTree.getRootNode();
+ traceNode = fStatsTree.getNode(fTestName);
+ catNode = traceNode.getChildren().iterator().next();
+ elementNode = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
elementNode.reset();
- assertEquals("reset", 0, elementNode.getValue().getTotal());
- assertEquals("reset", 0, elementNode.getValue().getPartial());
+ assertEquals(0, elementNode.getValues().getTotal());
+ assertEquals(0, elementNode.getValues().getPartial());
catNode.reset();
- assertEquals("reset", 0, catNode.getValue().getTotal());
- assertEquals("reset", 0, catNode.getValue().getPartial());
- assertEquals("reset", 0, catNode.getNbChildren());
- assertNull("reset", fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName())));
+ assertEquals(0, catNode.getValues().getTotal());
+ assertEquals(0, catNode.getValues().getPartial());
+ assertEquals(0, catNode.getNbChildren());
+ assertNull(fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1));
traceNode.reset();
- assertEquals("reset", 0, traceNode.getValue().getTotal());
- assertEquals("reset", 0, traceNode.getValue().getPartial());
- // A trace always have at least one child that is eventType
- assertEquals("reset", 1, traceNode.getNbChildren());
+ assertEquals(0, traceNode.getValues().getTotal());
+ assertEquals(0, traceNode.getValues().getPartial());
+ assertEquals(0, traceNode.getNbChildren());
rootNode.reset();
- assertEquals("reset", 0, rootNode.getValue().getTotal());
- assertEquals("reset", 0, rootNode.getValue().getPartial());
- assertEquals("reset", 1, rootNode.getNbChildren());
+ assertEquals(0, rootNode.getValues().getTotal());
+ assertEquals(0, rootNode.getValues().getPartial());
+ assertEquals(0, rootNode.getNbChildren());
}
/**
* Test reset global value of the node in the tree. It should only clear
* the global value without removing any node from the tree.
*/
+ @Test
public void testResetGlobalValue() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
- TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next();
- TmfStatisticsTreeNode eventTypeNode1 = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName()));
- TmfStatisticsTreeNode eventTypeNode2 = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType2.getName()));
+ TmfStatisticsTreeNode rootNode, traceNode, catNode, eventTypeNode1, eventTypeNode2, eventTypeNode3;
+ rootNode = fStatsTree.getRootNode();
+ traceNode = fStatsTree.getNode(fTestName);
+ catNode = traceNode.getChildren().iterator().next();
+ eventTypeNode1 = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
+ eventTypeNode2 = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId2);
+ eventTypeNode3 = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId3);
rootNode.resetGlobalValue();
- assertEquals(0, rootNode.getValue().getTotal());
- assertEquals(0, traceNode.getValue().getTotal());
- assertEquals(0, catNode.getValue().getTotal());
- assertEquals(0, eventTypeNode1.getValue().getTotal());
- assertEquals(0, eventTypeNode2.getValue().getTotal());
+ assertEquals(0, rootNode.getValues().getTotal());
+ assertEquals(0, traceNode.getValues().getTotal());
+ assertEquals(0, catNode.getValues().getTotal());
+ assertEquals(0, eventTypeNode1.getValues().getTotal());
+ assertEquals(0, eventTypeNode2.getValues().getTotal());
+ assertEquals(0, eventTypeNode3.getValues().getTotal());
// Checks the state of the statistics tree
- Collection<TmfStatisticsTreeNode> rootChildren = rootNode.getAllChildren();
+ Collection<TmfStatisticsTreeNode> rootChildren = rootNode.getChildren();
assertEquals(1, rootChildren.size());
assertTrue(rootChildren.contains(traceNode));
- Collection<TmfStatisticsTreeNode> traceChildren = traceNode.getAllChildren();
+ Collection<TmfStatisticsTreeNode> traceChildren = traceNode.getChildren();
assertEquals(1, traceChildren.size());
assertTrue(traceChildren.contains(catNode));
- Collection<TmfStatisticsTreeNode> catChildren = catNode.getAllChildren();
- assertEquals(2, catChildren.size());
+ Collection<TmfStatisticsTreeNode> catChildren = catNode.getChildren();
+ assertEquals(3, catChildren.size());
assertTrue(catChildren.contains(eventTypeNode1));
assertTrue(catChildren.contains(eventTypeNode2));
+ assertTrue(catChildren.contains(eventTypeNode3));
}
/**
* Test reset time range value of the node in the tree. It should only clear
* the time range value without removing any node from the tree.
*/
+ @Test
public void testResetTimeRangeValue() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
- TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next();
- TmfStatisticsTreeNode eventTypeNode1 = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName()));
- TmfStatisticsTreeNode eventTypeNode2 = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType2.getName()));
+ TmfStatisticsTreeNode rootNode, traceNode, catNode, eventTypeNode1, eventTypeNode2, eventTypeNode3;
+ rootNode = fStatsTree.getRootNode();
+ traceNode = fStatsTree.getNode(fTestName);
+ catNode = traceNode.getChildren().iterator().next();
+ eventTypeNode1 = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
+ eventTypeNode2 = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId2);
+ eventTypeNode3 = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId3);
rootNode.resetTimeRangeValue();
- assertEquals(0, rootNode.getValue().getPartial());
- assertEquals(0, traceNode.getValue().getPartial());
- assertEquals(0, catNode.getValue().getPartial());
- assertEquals(0, eventTypeNode1.getValue().getPartial());
- assertEquals(0, eventTypeNode2.getValue().getPartial());
+ assertEquals(0, rootNode.getValues().getPartial());
+ assertEquals(0, traceNode.getValues().getPartial());
+ assertEquals(0, catNode.getValues().getPartial());
+ assertEquals(0, eventTypeNode1.getValues().getPartial());
+ assertEquals(0, eventTypeNode2.getValues().getPartial());
// Checks the state of the statistics tree
- Collection<TmfStatisticsTreeNode> rootChildren = rootNode.getAllChildren();
+ Collection<TmfStatisticsTreeNode> rootChildren = rootNode.getChildren();
assertEquals(1, rootChildren.size());
assertTrue(rootChildren.contains(traceNode));
- Collection<TmfStatisticsTreeNode> traceChildren = traceNode.getAllChildren();
+ Collection<TmfStatisticsTreeNode> traceChildren = traceNode.getChildren();
assertEquals(1, traceChildren.size());
assertTrue(traceChildren.contains(catNode));
- Collection<TmfStatisticsTreeNode> catChildren = catNode.getAllChildren();
- assertEquals(2, catChildren.size());
+ Collection<TmfStatisticsTreeNode> catChildren = catNode.getChildren();
+ assertEquals(3, catChildren.size());
assertTrue(catChildren.contains(eventTypeNode1));
assertTrue(catChildren.contains(eventTypeNode2));
+ assertTrue(catChildren.contains(eventTypeNode3));
+ }
+
+ /**
+ * Check if two String arrays are equals, by comparing their contents.
+ * Unlike Arrays.equals(), we can use varargs for the second argument.
+ */
+ private static boolean arraysEqual(String[] array1, String... array2) {
+ if (array1.length != array2.length) {
+ return false;
+ }
+ for (int i = 0; i < array1.length; i++) {
+ if (!array1[i].equals(array2[i])) {
+ return false;
+ }
+ }
+ return true;
}
}
projects / deliverable / tracecompass.git / blobdiff