1 /*******************************************************************************
2 * Copyright (c) 2013, 2014 École Polytechnique de Montréal
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
10 * Geneviève Bastien - Initial API and implementation
11 * Mathieu Rail - Added tests for getting a module's requirements
12 *******************************************************************************/
14 package org
.eclipse
.tracecompass
.tmf
.core
.tests
.analysis
;
16 import static org
.junit
.Assert
.assertEquals
;
17 import static org
.junit
.Assert
.assertFalse
;
18 import static org
.junit
.Assert
.assertNotNull
;
19 import static org
.junit
.Assert
.assertNull
;
20 import static org
.junit
.Assert
.assertTrue
;
21 import static org
.junit
.Assert
.fail
;
23 import java
.util
.HashMap
;
27 import org
.eclipse
.core
.runtime
.Platform
;
28 import org
.eclipse
.jdt
.annotation
.NonNull
;
29 import org
.eclipse
.osgi
.util
.NLS
;
30 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.IAnalysisModule
;
31 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.IAnalysisModuleHelper
;
32 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.Messages
;
33 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.TmfAnalysisManager
;
34 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.TmfAnalysisModuleHelperConfigElement
;
35 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.TmfAnalysisRequirement
;
36 import org
.eclipse
.tracecompass
.tmf
.core
.exceptions
.TmfAnalysisException
;
37 import org
.eclipse
.tracecompass
.tmf
.core
.tests
.shared
.TmfTestTrace
;
38 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfTrace
;
39 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTrace
;
40 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.experiment
.TmfExperiment
;
41 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.analysis
.TestAnalysis
;
42 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.analysis
.TestAnalysis2
;
43 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.analysis
.TestRequirementAnalysis
;
44 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
45 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.trace
.TmfTraceStub2
;
46 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.trace
.TmfTraceStub3
;
47 import org
.junit
.After
;
48 import org
.junit
.Before
;
49 import org
.junit
.Test
;
50 import org
.osgi
.framework
.Bundle
;
52 import com
.google
.common
.collect
.ImmutableSet
;
53 import com
.google
.common
.collect
.Multimap
;
56 * Test suite for the {@link TmfAnalysisModuleHelperConfigElement} class
58 * @author Geneviève Bastien
60 public class AnalysisModuleHelperTest
{
62 private IAnalysisModuleHelper fModule
;
63 private IAnalysisModuleHelper fModuleOther
;
64 private IAnalysisModuleHelper fReqModule
;
65 private ITmfTrace fTrace
;
67 private static IAnalysisModuleHelper
getModuleHelper(@NonNull String moduleId
) {
68 Multimap
<String
, IAnalysisModuleHelper
> helpers
= TmfAnalysisManager
.getAnalysisModules();
69 assertEquals(1, helpers
.get(moduleId
).size());
70 return helpers
.get(moduleId
).iterator().next();
74 * Gets the module helpers for 2 test modules
77 public void getModules() {
78 fModule
= getModuleHelper(AnalysisManagerTest
.MODULE_PARAM
);
79 assertNotNull(fModule
);
80 assertTrue(fModule
instanceof TmfAnalysisModuleHelperConfigElement
);
81 fModuleOther
= getModuleHelper(AnalysisManagerTest
.MODULE_SECOND
);
82 assertNotNull(fModuleOther
);
83 assertTrue(fModuleOther
instanceof TmfAnalysisModuleHelperConfigElement
);
84 fReqModule
= getModuleHelper(AnalysisManagerTest
.MODULE_REQ
);
85 assertNotNull(fReqModule
);
86 assertTrue(fReqModule
instanceof TmfAnalysisModuleHelperConfigElement
);
87 fTrace
= TmfTestTrace
.A_TEST_10K2
.getTraceAsStub2();
91 * Some tests use traces, let's clean them here
94 public void cleanupTraces() {
95 TmfTestTrace
.A_TEST_10K
.dispose();
100 * Test the helper's getters and setters
103 public void testHelperGetters() {
104 /* With first module */
105 assertEquals(AnalysisManagerTest
.MODULE_PARAM
, fModule
.getId());
106 assertEquals("Test analysis", fModule
.getName());
107 assertFalse(fModule
.isAutomatic());
109 Bundle helperbundle
= fModule
.getBundle();
110 Bundle thisbundle
= Platform
.getBundle("org.eclipse.tracecompass.tmf.core.tests");
111 assertNotNull(helperbundle
);
112 assertEquals(thisbundle
, helperbundle
);
114 /* With other module */
115 assertEquals(AnalysisManagerTest
.MODULE_SECOND
, fModuleOther
.getId());
116 assertEquals("Test other analysis", fModuleOther
.getName());
117 assertTrue(fModuleOther
.isAutomatic());
122 * {@link TmfAnalysisModuleHelperConfigElement#appliesToTraceType(Class)}
123 * method for the 2 modules
126 public void testAppliesToTrace() {
128 assertFalse(fModule
.appliesToTraceType(TmfTrace
.class));
129 assertTrue(fModule
.appliesToTraceType(TmfTraceStub
.class));
130 assertTrue(fModule
.appliesToTraceType(TmfTraceStub2
.class));
131 assertFalse(fModule
.appliesToTraceType(TmfTraceStub3
.class));
132 assertFalse(fModule
.appliesToTraceType(TmfExperiment
.class));
135 assertFalse(fModuleOther
.appliesToTraceType(TmfTrace
.class));
136 assertFalse(fModuleOther
.appliesToTraceType(TmfTraceStub
.class));
137 assertTrue(fModuleOther
.appliesToTraceType(TmfTraceStub2
.class));
138 assertTrue(fModuleOther
.appliesToTraceType(TmfTraceStub3
.class));
139 assertFalse(fModuleOther
.appliesToTraceType(TmfExperiment
.class));
144 * {@link TmfAnalysisModuleHelperConfigElement#newModule(ITmfTrace)} method
148 public void testNewModule() {
149 /* Test analysis module with traceStub */
150 Exception exception
= null;
151 IAnalysisModule module
= null;
153 module
= fModule
.newModule(TmfTestTrace
.A_TEST_10K
.getTrace());
154 assertNotNull(module
);
155 assertTrue(module
instanceof TestAnalysis
);
156 } catch (TmfAnalysisException e
) {
159 if (module
!= null) {
163 assertNull(exception
);
165 /* TestAnalysis2 module with trace, should return an exception */
167 module
= fModuleOther
.newModule(TmfTestTrace
.A_TEST_10K
.getTrace());
168 } catch (TmfAnalysisException e
) {
171 if (module
!= null) {
175 assertNotNull(exception
);
176 assertEquals(NLS
.bind(Messages
.TmfAnalysisModuleHelper_AnalysisDoesNotApply
, fModuleOther
.getName()), exception
.getMessage());
178 /* TestAnalysis2 module with a TraceStub2 */
180 ITmfTrace trace
= fTrace
;
181 assertNotNull(trace
);
183 module
= fModuleOther
.newModule(trace
);
184 assertNotNull(module
);
185 assertTrue(module
instanceof TestAnalysis2
);
186 } catch (TmfAnalysisException e
) {
189 if (module
!= null) {
193 assertNull(exception
);
198 * Test the analysis modules with a differing result for experiments
201 public void testAppliesToExperiment() {
202 ITmfTrace trace1
= TmfTestTrace
.A_TEST_10K
.getTrace();
203 ITmfTrace trace2
= TmfTestTrace
.A_TEST_10K2
.getTrace();
204 ITmfTrace trace3
= TmfTestTrace
.A_TEST_10K2
.getTraceAsStub2();
206 /* Create an experiment with TmfTraceStub */
207 ITmfTrace
[] tracesExp1
= { trace1
, trace2
};
208 TmfExperiment exp1
= new TmfExperiment(tracesExp1
[0].getEventType(), "Experiment 1", tracesExp1
, TmfExperiment
.DEFAULT_INDEX_PAGE_SIZE
, null);
210 /* Create an experiment containing some TmfTraceStub2 */
211 ITmfTrace
[] tracesExp2
= { trace1
, trace3
};
212 TmfExperiment exp2
= new TmfExperiment(tracesExp2
[0].getEventType(), "Experiment 1", tracesExp2
, TmfExperiment
.DEFAULT_INDEX_PAGE_SIZE
, null);
216 /* fModule should throw exception for both experiments */
217 Exception exception
= null;
218 IAnalysisModule module
= null;
220 module
= fModule
.newModule(exp1
);
221 } catch (TmfAnalysisException e
) {
224 if (module
!= null) {
228 assertNotNull(exception
);
229 assertEquals(NLS
.bind(Messages
.TmfAnalysisModuleHelper_AnalysisDoesNotApply
, fModule
.getName()), exception
.getMessage());
233 module
= fModule
.newModule(exp2
);
234 } catch (TmfAnalysisException e
) {
237 if (module
!= null) {
241 assertNotNull(exception
);
242 assertEquals(NLS
.bind(Messages
.TmfAnalysisModuleHelper_AnalysisDoesNotApply
, fModule
.getName()), exception
.getMessage());
244 /* fModuleOther should throw exception for exp1, but not exp2 */
247 module
= fModuleOther
.newModule(exp1
);
248 } catch (TmfAnalysisException e
) {
251 if (module
!= null) {
255 assertNotNull(exception
);
256 assertEquals(NLS
.bind(Messages
.TmfAnalysisModuleHelper_AnalysisDoesNotApply
, fModuleOther
.getName()), exception
.getMessage());
260 module
= fModuleOther
.newModule(exp2
);
261 assertNotNull(module
);
262 } catch (TmfAnalysisException e
) {
265 if (module
!= null) {
269 assertNull(exception
);
278 * Test for the initialization of parameters from the extension points
281 public void testParameters() {
282 ITmfTrace trace
= TmfTestTrace
.A_TEST_10K
.getTrace();
285 * This analysis has a parameter, but no default value. we should be
286 * able to set the parameter
288 IAnalysisModuleHelper helper
= getModuleHelper(AnalysisManagerTest
.MODULE_PARAM
);
289 assertNotNull(helper
);
290 IAnalysisModule module
= null;
292 module
= helper
.newModule(trace
);
293 assertNull(module
.getParameter(TestAnalysis
.PARAM_TEST
));
294 module
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
295 assertEquals(1, module
.getParameter(TestAnalysis
.PARAM_TEST
));
297 } catch (TmfAnalysisException e1
) {
298 fail(e1
.getMessage());
301 if (module
!= null) {
306 /* This module has a parameter with default value */
307 helper
= getModuleHelper(AnalysisManagerTest
.MODULE_PARAM_DEFAULT
);
308 assertNotNull(helper
);
310 module
= helper
.newModule(trace
);
311 assertEquals(3, module
.getParameter(TestAnalysis
.PARAM_TEST
));
312 module
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
313 assertEquals(1, module
.getParameter(TestAnalysis
.PARAM_TEST
));
315 } catch (TmfAnalysisException e1
) {
316 fail(e1
.getMessage());
319 if (module
!= null) {
325 * This module does not have a parameter so setting it should throw an
328 helper
= getModuleHelper(AnalysisManagerTest
.MODULE_SECOND
);
329 assertNotNull(helper
);
330 Exception exception
= null;
332 assertNotNull(trace
);
334 module
= helper
.newModule(trace
);
335 assertNull(module
.getParameter(TestAnalysis
.PARAM_TEST
));
338 module
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
339 } catch (RuntimeException e
) {
342 } catch (TmfAnalysisException e1
) {
343 fail(e1
.getMessage());
346 if (module
!= null) {
350 assertNotNull(exception
);
355 * {@link TmfAnalysisModuleHelperConfigElement#getValidTraceTypes} method
358 public void testGetValidTraceTypes() {
359 Set
<Class
<?
extends ITmfTrace
>> expected
= ImmutableSet
.of((Class
<?
extends ITmfTrace
>) TmfTraceStub
.class, TmfTraceStub2
.class, TmfTraceStub3
.class);
360 Iterable
<Class
<?
extends ITmfTrace
>> traceTypes
= fReqModule
.getValidTraceTypes();
361 assertEquals(expected
, traceTypes
);
366 * {@link TmfAnalysisModuleHelperConfigElement#getAnalysisRequirements}
370 public void testGetRequirements() {
371 Iterable
<TmfAnalysisRequirement
> requirements
= fReqModule
.getAnalysisRequirements();
372 assertNotNull(requirements
);
374 Map
<String
, TmfAnalysisRequirement
> rMap
= new HashMap
<>();
376 for (TmfAnalysisRequirement req
: requirements
) {
377 assertFalse(rMap
.containsKey(req
.getType()));
378 rMap
.put(req
.getType(), req
);
380 assertEquals(2, rMap
.size());
382 /* Test if all types and values have been obtained */
383 TmfAnalysisRequirement req
= rMap
.get(TestRequirementAnalysis
.EVENT_TYPE
);
386 Set
<String
> values
= req
.getValues();
387 assertEquals(3, values
.size());
388 assertTrue(values
.contains(TestRequirementAnalysis
.EXIT_SYSCALL
));
389 assertTrue(values
.contains(TestRequirementAnalysis
.SCHED_SWITCH
));
390 assertTrue(values
.contains(TestRequirementAnalysis
.SCHED_WAKEUP
));
392 req
= rMap
.get(TestRequirementAnalysis
.FIELD_TYPE
);
395 values
= req
.getValues();
396 assertEquals(2, values
.size());
397 assertTrue(values
.contains(TestRequirementAnalysis
.PID
));
398 assertTrue(values
.contains(TestRequirementAnalysis
.TID
));