Commit | Line | Data |
---|---|---|
79e08fd0 BH |
1 | /******************************************************************************* |
2 | * Copyright (c) 2011 Ericsson | |
3 | * | |
4 | * All rights reserved. This program and the accompanying materials are | |
5 | * made available under the terms of the Eclipse Public License v1.0 which | |
6 | * accompanies this distribution, and is available at | |
7 | * http://www.eclipse.org/legal/epl-v10.html | |
8 | * | |
9 | * Contributors: | |
10 | * Mathieu Denis (mathieu.denis@polymtl.ca) - Initial design and implementation | |
11 | * Bernd Hufmann - Fixed warnings | |
12 | *******************************************************************************/ | |
13 | ||
14 | package org.eclipse.linuxtools.tmf.ui.tests.statistics; | |
15 | ||
16 | import java.util.Collection; | |
17 | import java.util.Iterator; | |
18 | import java.util.Vector; | |
19 | ||
20 | import junit.framework.TestCase; | |
21 | ||
6c13869b FC |
22 | import org.eclipse.linuxtools.tmf.core.event.TmfEvent; |
23 | import org.eclipse.linuxtools.tmf.core.event.TmfEventContent; | |
24 | import org.eclipse.linuxtools.tmf.core.event.TmfEventReference; | |
6c13869b FC |
25 | import org.eclipse.linuxtools.tmf.core.event.TmfEventType; |
26 | import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp; | |
27 | import org.eclipse.linuxtools.tmf.core.util.TmfFixedArray; | |
79e08fd0 | 28 | import org.eclipse.linuxtools.tmf.ui.views.statistics.ITmfExtraEventInfo; |
99005796 | 29 | import org.eclipse.linuxtools.tmf.ui.views.statistics.model.AbsTmfStatisticsTree; |
79e08fd0 BH |
30 | import org.eclipse.linuxtools.tmf.ui.views.statistics.model.Messages; |
31 | import org.eclipse.linuxtools.tmf.ui.views.statistics.model.TmfBaseStatisticsTree; | |
79e08fd0 | 32 | import org.eclipse.linuxtools.tmf.ui.views.statistics.model.TmfStatisticsTreeNode; |
79e08fd0 BH |
33 | |
34 | @SuppressWarnings("nls") | |
35 | public class TmfStatisticsTreeNodeTest extends TestCase { | |
36 | ||
37 | // ------------------------------------------------------------------------ | |
38 | // Fields | |
39 | // ------------------------------------------------------------------------ | |
40 | private String fTestName = null; | |
41 | ||
42 | ||
43 | private final String fTypeId1 = "Some type1"; | |
44 | private final String fTypeId2 = "Some type2"; | |
45 | ||
46 | private final String fLabel0 = "label1"; | |
47 | private final String fLabel1 = "label2"; | |
48 | private final String fLabel2 = "label3"; | |
49 | private final String[] fLabels = new String[] { fLabel0, fLabel1, fLabel2 }; | |
50 | ||
51 | private final TmfTimestamp fTimestamp1 = new TmfTimestamp(12345, (byte) 2, 5); | |
52 | private final TmfTimestamp fTimestamp2 = new TmfTimestamp(12350, (byte) 2, 5); | |
53 | private final TmfTimestamp fTimestamp3 = new TmfTimestamp(12355, (byte) 2, 5); | |
54 | ||
99005796 | 55 | private final String fSource = "Source"; |
79e08fd0 BH |
56 | |
57 | private final TmfEventType fType1 = new TmfEventType(fTypeId1, fLabels); | |
58 | private final TmfEventType fType2 = new TmfEventType(fTypeId1, fLabels); | |
59 | private final TmfEventType fType3 = new TmfEventType(fTypeId2, fLabels); | |
60 | ||
61 | private final TmfEventReference fReference = new TmfEventReference("Some reference"); | |
62 | ||
63 | private final TmfEvent fEvent1; | |
64 | private final TmfEvent fEvent2; | |
65 | private final TmfEvent fEvent3; | |
66 | ||
67 | private final TmfEventContent fContent1; | |
68 | private final TmfEventContent fContent2; | |
69 | private final TmfEventContent fContent3; | |
70 | ||
71 | private final TmfBaseStatisticsTree fStatsData; | |
72 | ||
73 | private final ITmfExtraEventInfo fExtraInfo; | |
74 | ||
75 | // ------------------------------------------------------------------------ | |
76 | // Housekeeping | |
77 | // ------------------------------------------------------------------------ | |
78 | ||
79 | /** | |
80 | * @param name of the test | |
81 | */ | |
82 | public TmfStatisticsTreeNodeTest(final String name) { | |
83 | super(name); | |
84 | ||
85 | fTestName = name; | |
86 | ||
87 | fEvent1 = new TmfEvent(fTimestamp1, fSource, fType1, fReference); | |
88 | fContent1 = new TmfEventContent(fEvent1, "Some content"); | |
89 | fEvent1.setContent(fContent1); | |
90 | ||
ce970a71 | 91 | fEvent2 = new TmfEvent(fTimestamp2, fSource, fType2, fReference); |
79e08fd0 BH |
92 | fContent2 = new TmfEventContent(fEvent2, "Some other content"); |
93 | fEvent2.setContent(fContent2); | |
94 | ||
ce970a71 | 95 | fEvent3 = new TmfEvent(fTimestamp3, fSource, fType3, fReference); |
79e08fd0 BH |
96 | fContent3 = new TmfEventContent(fEvent3, "Some other different content"); |
97 | fEvent3.setContent(fContent3); | |
98 | ||
99 | fStatsData = new TmfBaseStatisticsTree(); | |
100 | fExtraInfo = new ITmfExtraEventInfo() { | |
101 | @Override | |
102 | public String getTraceName() { | |
103 | return name; | |
104 | } | |
105 | }; | |
106 | fStatsData.registerEvent(fEvent1, fExtraInfo); | |
107 | fStatsData.registerEvent(fEvent2, fExtraInfo); | |
108 | fStatsData.registerEvent(fEvent3, fExtraInfo); | |
109 | } | |
110 | ||
111 | // ------------------------------------------------------------------------ | |
112 | // ContainsChild | |
113 | // ------------------------------------------------------------------------ | |
114 | ||
115 | public void testContainsChild() { | |
116 | TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT); | |
117 | TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName)); | |
118 | // Creates a category from the key already created | |
119 | TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next(); | |
120 | ||
121 | assertTrue("containsChild", rootNode.containsChild(fTestName)); | |
122 | assertFalse("containsChild", rootNode.containsChild(catNode.getKey())); | |
123 | assertFalse("containsChild", rootNode.containsChild(null)); | |
124 | ||
125 | assertTrue("containsChild", traceNode.containsChild(catNode.getKey())); | |
126 | assertFalse("containsChild", traceNode.containsChild(fEvent1.getType().toString())); | |
127 | assertFalse("containsChild", traceNode.containsChild(null)); | |
128 | ||
129 | assertTrue("containsChild", catNode.containsChild(fEvent1.getType().toString())); | |
130 | assertTrue("containsChild", catNode.containsChild(fEvent3.getType().toString())); | |
131 | assertFalse("containsChild", catNode.containsChild(null)); | |
132 | } | |
133 | ||
134 | // ------------------------------------------------------------------------ | |
135 | // GetChildren | |
136 | // ------------------------------------------------------------------------ | |
137 | ||
138 | public void testGetChildren() { | |
139 | // Getting children of the ROOT | |
140 | Collection<TmfStatisticsTreeNode> childrenTreeNode = fStatsData.get(AbsTmfStatisticsTree.ROOT).getChildren(); | |
141 | assertEquals("getChildren", 1, childrenTreeNode.size()); | |
142 | TmfStatisticsTreeNode treeNode = childrenTreeNode.iterator().next(); | |
143 | assertEquals("getChildren", fTestName, treeNode.getKey()); | |
144 | ||
145 | // Getting children of the trace | |
146 | childrenTreeNode = fStatsData.get(new TmfFixedArray<String>(fTestName)).getChildren(); | |
147 | assertEquals("getChildren", 1, childrenTreeNode.size()); | |
148 | treeNode = childrenTreeNode.iterator().next(); | |
149 | assertEquals("getChildren", Messages.TmfStatisticsData_EventTypes, treeNode.getKey()); | |
150 | ||
151 | Vector<String> keyExpected = new Vector<String>(); | |
152 | keyExpected.add(fEvent1.getType().toString()); | |
153 | keyExpected.add(fEvent3.getType().toString()); | |
154 | // Getting children of a category | |
155 | childrenTreeNode = treeNode.getChildren(); | |
156 | assertEquals("getChildren", 2, childrenTreeNode.size()); | |
157 | ||
158 | Iterator<TmfStatisticsTreeNode> iterChild = childrenTreeNode.iterator(); | |
159 | TmfStatisticsTreeNode temp; | |
160 | while (iterChild.hasNext()) { | |
161 | temp = iterChild.next(); | |
162 | if (keyExpected.contains(temp.getKey())) { | |
163 | keyExpected.removeElement(temp.getKey()); | |
164 | } | |
165 | else { | |
166 | fail(); | |
167 | } | |
168 | } | |
169 | ||
170 | // Get children of a specific event type | |
171 | childrenTreeNode = fStatsData.get(childrenTreeNode.iterator().next().getPath()).getChildren(); | |
172 | assertEquals("getChildren", 0, childrenTreeNode.size()); | |
173 | } | |
174 | ||
175 | // ------------------------------------------------------------------------ | |
176 | // GetAllChildren | |
177 | // ------------------------------------------------------------------------ | |
178 | ||
179 | public void testGetAllChildren() { | |
180 | // Getting children of the ROOT | |
181 | Collection<TmfStatisticsTreeNode> childrenTreeNode = fStatsData.get(AbsTmfStatisticsTree.ROOT).getAllChildren(); | |
182 | assertEquals("getChildren", 1, childrenTreeNode.size()); | |
183 | TmfStatisticsTreeNode treeNode = childrenTreeNode.iterator().next(); | |
184 | assertEquals("getChildren", fTestName, treeNode.getKey()); | |
185 | ||
186 | // Getting children of the trace | |
187 | childrenTreeNode = fStatsData.get(new TmfFixedArray<String>(fTestName)).getAllChildren(); | |
188 | assertEquals("getChildren", 1, childrenTreeNode.size()); | |
189 | treeNode = childrenTreeNode.iterator().next(); | |
190 | assertEquals("getChildren", Messages.TmfStatisticsData_EventTypes, treeNode.getKey()); | |
191 | ||
192 | Vector<String> keyExpected = new Vector<String>(); | |
193 | keyExpected.add(fEvent1.getType().toString()); | |
194 | keyExpected.add(fEvent3.getType().toString()); | |
195 | // It should return the eventType even though the number of events equals 0 | |
196 | fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString())).reset(); | |
197 | // Getting children of a category | |
198 | childrenTreeNode = treeNode.getAllChildren(); | |
199 | assertEquals("getChildren", 2, childrenTreeNode.size()); | |
200 | ||
201 | Iterator<TmfStatisticsTreeNode> iterChild = childrenTreeNode.iterator(); | |
202 | TmfStatisticsTreeNode temp; | |
203 | while (iterChild.hasNext()) { | |
204 | temp = iterChild.next(); | |
205 | if (keyExpected.contains(temp.getKey())) { | |
206 | keyExpected.removeElement(temp.getKey()); | |
207 | } | |
208 | else { | |
209 | fail(); | |
210 | } | |
211 | } | |
212 | ||
213 | // Get children of a specific event type | |
214 | childrenTreeNode = fStatsData.get(childrenTreeNode.iterator().next().getPath()).getAllChildren(); | |
215 | assertEquals("getChildren", 0, childrenTreeNode.size()); | |
216 | } | |
217 | ||
218 | // ------------------------------------------------------------------------ | |
219 | // GetNbChildren | |
220 | // ------------------------------------------------------------------------ | |
221 | ||
222 | public void testGetNbChildren() { | |
223 | TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT); | |
224 | TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName)); | |
225 | TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next(); | |
226 | TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString())); | |
227 | ||
228 | assertEquals("getNbChildren", 1, rootNode.getNbChildren()); | |
229 | assertEquals("getNbChildren", 1, traceNode.getNbChildren()); | |
230 | assertEquals("getNbChildren", 2, catNode.getNbChildren()); | |
231 | assertEquals("getNbChildren", 0, elementNode.getNbChildren()); | |
232 | } | |
233 | ||
234 | // ------------------------------------------------------------------------ | |
235 | // HasChildren | |
236 | // ------------------------------------------------------------------------ | |
237 | ||
238 | public void testHasChildren() { | |
239 | TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT); | |
240 | TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName)); | |
241 | TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next(); | |
242 | TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString())); | |
243 | ||
244 | assertTrue ("hasChildren", rootNode.hasChildren()); | |
245 | assertTrue ("hasChildren", traceNode.hasChildren()); | |
246 | assertTrue ("hasChildren", catNode.hasChildren()); | |
247 | assertFalse("hasChildren", elementNode.hasChildren()); | |
248 | } | |
249 | ||
250 | // ------------------------------------------------------------------------ | |
251 | // GetParent | |
252 | // ------------------------------------------------------------------------ | |
253 | ||
254 | public void testGetParent() { | |
255 | TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT); | |
256 | TmfStatisticsTreeNode parentNode = rootNode.getParent(); | |
257 | assertNull("getParent", parentNode); | |
258 | ||
259 | TmfStatisticsTreeNode newTraceNode = new TmfStatisticsTreeNode(new TmfFixedArray<String>("newly created trace node"), fStatsData); | |
260 | parentNode = newTraceNode.getParent(); | |
261 | assertNotNull("getParent", parentNode); | |
262 | assertEquals("getParent", 0, parentNode.getKey().compareTo(fStatsData.get(AbsTmfStatisticsTree.ROOT).getKey().toString())); | |
263 | ||
264 | TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName)); | |
265 | parentNode = traceNode.getParent(); | |
266 | assertNotNull("getParent", parentNode); | |
267 | assertEquals("getParent", 0, parentNode.getPath().toString().compareTo(AbsTmfStatisticsTree.ROOT.toString())); | |
268 | ||
269 | TmfStatisticsTreeNode newNode = new TmfStatisticsTreeNode(new TmfFixedArray<String>("TreeNode", Messages.TmfStatisticsData_EventTypes, "TreeNode that should not exist"), fStatsData); | |
270 | parentNode = newNode.getParent(); | |
271 | assertNull("getParent", parentNode); | |
272 | ||
273 | TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString())); | |
274 | parentNode = elementNode.getParent(); | |
275 | assertNull("getParent", parentNode); | |
276 | ||
277 | TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next(); | |
278 | parentNode = catNode.getParent(); | |
279 | assertNotNull("getParent", parentNode); | |
280 | assertEquals("getParent", 0, parentNode.getPath().toString().compareTo(fStatsData.get(new TmfFixedArray<String>(fTestName)).getPath().toString())); | |
281 | ||
282 | parentNode = elementNode.getParent(); | |
283 | assertNotNull("getParent", parentNode); | |
284 | assertTrue("getParent", parentNode.getPath().equals(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes))); | |
285 | } | |
286 | ||
287 | // ------------------------------------------------------------------------ | |
288 | // GetKey | |
289 | // ------------------------------------------------------------------------ | |
290 | ||
291 | public void testGetKey() { | |
292 | TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT); | |
293 | TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName)); | |
294 | TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next(); | |
295 | TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString())); | |
296 | ||
297 | assertEquals("getKey", 0, rootNode.getKey().compareTo(AbsTmfStatisticsTree.ROOT.get(0))); | |
298 | assertEquals("getKey", 0, traceNode.getKey().compareTo(fTestName)); | |
299 | assertEquals("getKey", 0, catNode.getKey().compareTo(Messages.TmfStatisticsData_EventTypes)); | |
300 | assertEquals("getKey", 0, elementNode.getKey().compareTo(fEvent1.getType().toString())); | |
301 | } | |
302 | ||
303 | // ------------------------------------------------------------------------ | |
304 | // GetPath | |
305 | // ------------------------------------------------------------------------ | |
306 | ||
307 | public void testGetPath() { | |
308 | TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT); | |
309 | TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName)); | |
310 | TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next(); | |
311 | TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString())); | |
312 | ||
313 | assertTrue("getPath", rootNode.getPath().equals(AbsTmfStatisticsTree.ROOT)); | |
314 | assertTrue("getPath", traceNode.getPath().equals(new TmfFixedArray<String>(fTestName))); | |
315 | assertTrue("getPath", catNode.getPath().equals(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes))); | |
316 | assertTrue("getPath", elementNode.getPath().equals(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString()))); | |
317 | } | |
318 | ||
319 | // ------------------------------------------------------------------------ | |
320 | // GetValue | |
321 | // ------------------------------------------------------------------------ | |
322 | ||
323 | public void testGetValue() { | |
324 | TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT); | |
325 | TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName)); | |
326 | TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next(); | |
327 | TmfStatisticsTreeNode elementNode1 = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString())); | |
328 | TmfStatisticsTreeNode elementNode2 = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent3.getType().toString())); | |
329 | ||
330 | assertEquals("getValue", 0, rootNode.getValue().nbEvents); | |
331 | assertEquals("getValue", 3, traceNode.getValue().nbEvents); | |
332 | assertEquals("getValue", 0, catNode.getValue().nbEvents); | |
333 | assertEquals("getValue", 2, elementNode1.getValue().nbEvents); | |
334 | assertEquals("getValue", 1, elementNode2.getValue().nbEvents); | |
335 | } | |
336 | ||
337 | // ------------------------------------------------------------------------ | |
338 | // Reset | |
339 | // ------------------------------------------------------------------------ | |
340 | ||
341 | public void testReset() { | |
342 | TmfStatisticsTreeNode rootNode = fStatsData.get(AbsTmfStatisticsTree.ROOT); | |
343 | TmfStatisticsTreeNode traceNode = fStatsData.get(new TmfFixedArray<String>(fTestName)); | |
344 | TmfStatisticsTreeNode catNode = traceNode.getChildren().iterator().next(); | |
345 | TmfStatisticsTreeNode elementNode = fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString())); | |
346 | ||
347 | elementNode.reset(); | |
348 | assertEquals("reset", 0, elementNode.getValue().nbEvents); | |
349 | ||
350 | catNode.reset(); | |
351 | assertEquals("reset", 0, catNode.getValue().nbEvents); | |
352 | assertEquals("reset", 0, catNode.getNbChildren()); | |
353 | assertNull("reset", fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fEvent1.getType().toString()))); | |
354 | ||
355 | traceNode.reset(); | |
356 | assertEquals("reset", 0, traceNode.getValue().nbEvents); | |
357 | // A trace always have at least one child that is eventType | |
358 | assertEquals("reset", 1, traceNode.getNbChildren()); | |
359 | ||
360 | rootNode.reset(); | |
361 | assertEquals("reset", 0, rootNode.getValue().nbEvents); | |
362 | assertEquals("reset", 1, rootNode.getNbChildren()); | |
363 | } | |
364 | } |