/*******************************************************************************
- * 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
* accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
- *
+ *
* Contributors:
- * Mathieu Denis (mathieu.denis@polymtl.ca) - Initial design and implementation
+ * 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.views.statistics.ITmfExtraEventInfo;
-import org.eclipse.linuxtools.tmf.ui.views.statistics.model.AbsTmfStatisticsTree;
-import org.eclipse.linuxtools.tmf.ui.views.statistics.model.Messages;
-import org.eclipse.linuxtools.tmf.ui.views.statistics.model.TmfBaseStatisticsTree;
-import org.eclipse.linuxtools.tmf.ui.views.statistics.model.TmfStatisticsTreeNode;
+import org.eclipse.linuxtools.tmf.ui.viewers.statistics.model.Messages;
+import org.eclipse.linuxtools.tmf.ui.viewers.statistics.model.TmfStatisticsTree;
+import org.eclipse.linuxtools.tmf.ui.viewers.statistics.model.TmfStatisticsTreeNode;
+import org.junit.Test;
-@SuppressWarnings("nls")
-public class TmfStatisticsTreeNodeTest extends TestCase {
+/**
+ * TmfStatisticsTreeNode Test Cases.
+ */
+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 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, fTypeId1, TmfEventField.makeRoot(fLabels));
- private final TmfEventType fType3 = new TmfEventType(fContext, fTypeId2, TmfEventField.makeRoot(fLabels));
-
- 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 final String fTypeId3 = "Some type3";
+
+ private final TmfStatisticsTree fStatsTree;
+
+ private static final String fTestName = "StatisticsTreeNodeTest";
+
// ------------------------------------------------------------------------
// Housekeeping
// ------------------------------------------------------------------------
-
+
/**
- * @param name of the test
+ * Constructor
*/
- public TmfStatisticsTreeNodeTest(final String name) {
- super(name);
-
- fTestName = name;
-
- fEvent1 = new TmfEvent(fTimestamp1, fSource, fType1, fReference);
- fContent1 = new TmfEventField(ITmfEventField.ROOT_ID, "Some content");
- fEvent1.setContent(fContent1);
-
- fEvent2 = new TmfEvent(fTimestamp2, fSource, fType2, fReference);
- fContent2 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other content");
- fEvent2.setContent(fContent2);
-
- fEvent3 = new TmfEvent(fTimestamp3, fSource, fType3, fReference);
- fContent3 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other different content");
- fEvent3.setContent(fContent3);
-
- fStatsData = new TmfBaseStatisticsTree();
- fExtraInfo = new ITmfExtraEventInfo() {
- @Override
- public String getTraceName() {
- return name;
- }
- };
- fStatsData.registerEvent(fEvent1, fExtraInfo);
- fStatsData.registerEvent(fEvent2, fExtraInfo);
- fStatsData.registerEvent(fEvent3, fExtraInfo);
+ 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("containsChild", traceNode.containsChild(catNode.getKey()));
- assertFalse("containsChild", traceNode.containsChild(fEvent1.getType().toString()));
- assertFalse("containsChild", traceNode.containsChild(null));
-
- assertTrue("containsChild", catNode.containsChild(fEvent1.getType().toString()));
- assertTrue("containsChild", catNode.containsChild(fEvent3.getType().toString()));
- assertFalse("containsChild", catNode.containsChild(null));
+
+ assertTrue(rootNode.containsChild(fTestName));
+ assertFalse(rootNode.containsChild(catNode.getName()));
+ assertFalse(rootNode.containsChild(null));
+
+ assertTrue(traceNode.containsChild(catNode.getName()));
+ assertFalse(traceNode.containsChild(fTypeId1));
+ assertFalse(traceNode.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());
-
- Vector<String> keyExpected = new Vector<String>();
- keyExpected.add(fEvent1.getType().toString());
- keyExpected.add(fEvent3.getType().toString());
+ assertEquals(Messages.TmfStatisticsData_EventTypes, treeNode.getName());
+
+ Vector<String> keyExpected = new Vector<String>();
+ keyExpected.add(fTypeId1);
+ keyExpected.add(fTypeId2);
+ keyExpected.add(fTypeId3);
// Getting children of a category
childrenTreeNode = treeNode.getChildren();
- 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()).getChildren();
- assertEquals("getChildren", 0, childrenTreeNode.size());
- }
-
- // ------------------------------------------------------------------------
- // GetAllChildren
- // ------------------------------------------------------------------------
+ assertEquals(3, childrenTreeNode.size());
- 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(fEvent1.getType().toString());
- keyExpected.add(fEvent3.getType().toString());
- // It should return the eventType even though the number of events equals 0
- fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString())).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 {
+ 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()).getAllChildren();
- assertEquals("getChildren", 0, childrenTreeNode.size());
+ childrenTreeNode = fStatsTree.getNode(childrenTreeNode.iterator().next().getPath()).getChildren();
+ assertEquals(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, fEvent1.getType().toString()));
-
- assertEquals("getNbChildren", 1, rootNode.getNbChildren());
- assertEquals("getNbChildren", 1, traceNode.getNbChildren());
- assertEquals("getNbChildren", 2, catNode.getNbChildren());
- assertEquals("getNbChildren", 0, elementNode.getNbChildren());
+ TmfStatisticsTreeNode elementNode = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
+
+ 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, fEvent1.getType().toString()));
-
- assertTrue ("hasChildren", rootNode.hasChildren());
- assertTrue ("hasChildren", traceNode.hasChildren());
- assertTrue ("hasChildren", catNode.hasChildren());
- assertFalse("hasChildren", elementNode.hasChildren());
+ TmfStatisticsTreeNode elementNode = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
+
+ 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);
-
- TmfStatisticsTreeNode newTraceNode = new TmfStatisticsTreeNode(new TmfFixedArray<String>("newly created trace node"), fStatsData);
+ assertNull(parentNode);
+
+ 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()));
-
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
+ assertNotNull(parentNode);
+ assertTrue(fStatsTree.getRootNode() == parentNode);
+
+ 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);
-
- TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString()));
+ assertNotNull(parentNode);
+ assertTrue(rootNode == parentNode);
+
+ 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
- // ------------------------------------------------------------------------
-
- public void testGetKey() {
- TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT);
- TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName));
+
+ /**
+ * Test getting of key.
+ */
+ @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, fEvent1.getType().toString()));
-
- 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(fEvent1.getType().toString()));
+ TmfStatisticsTreeNode elementNode = fStatsTree.getNode(fTestName, Messages.TmfStatisticsData_EventTypes, fTypeId1);
+
+ 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, fEvent1.getType().toString()));
-
- 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, fEvent1.getType().toString())));
+ 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, fEvent1.getType().toString()));
- TmfStatisticsTreeNode elementNode2 = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent3.getType().toString()));
-
- assertEquals("getValue", 0, rootNode.getValue().nbEvents);
- assertEquals("getValue", 3, traceNode.getValue().nbEvents);
- assertEquals("getValue", 0, catNode.getValue().nbEvents);
- assertEquals("getValue", 2, elementNode1.getValue().nbEvents);
- assertEquals("getValue", 1, elementNode2.getValue().nbEvents);
+ 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, fEvent1.getType().toString()));
-
+ 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().nbEvents);
-
+ assertEquals(0, elementNode.getValues().getTotal());
+ assertEquals(0, elementNode.getValues().getPartial());
+
catNode.reset();
- assertEquals("reset", 0, catNode.getValue().nbEvents);
- assertEquals("reset", 0, catNode.getNbChildren());
- assertNull("reset", fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString())));
-
+ 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().nbEvents);
- // 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().nbEvents);
- 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, 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.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.getChildren();
+ assertEquals(1, rootChildren.size());
+ assertTrue(rootChildren.contains(traceNode));
+
+ Collection<TmfStatisticsTreeNode> traceChildren = traceNode.getChildren();
+ assertEquals(1, traceChildren.size());
+ assertTrue(traceChildren.contains(catNode));
+
+ 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, 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.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.getChildren();
+ assertEquals(1, rootChildren.size());
+ assertTrue(rootChildren.contains(traceNode));
+
+ Collection<TmfStatisticsTreeNode> traceChildren = traceNode.getChildren();
+ assertEquals(1, traceChildren.size());
+ assertTrue(traceChildren.contains(catNode));
+
+ 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;
}
}