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
;
25 import org
.eclipse
.core
.runtime
.Platform
;
26 import org
.eclipse
.jdt
.annotation
.NonNull
;
27 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.IAnalysisModule
;
28 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.IAnalysisModuleHelper
;
29 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.TmfAnalysisManager
;
30 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.TmfAnalysisModuleHelperConfigElement
;
31 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.requirements
.TmfAbstractAnalysisRequirement
;
32 import org
.eclipse
.tracecompass
.tmf
.core
.exceptions
.TmfAnalysisException
;
33 import org
.eclipse
.tracecompass
.tmf
.core
.tests
.shared
.TmfTestTrace
;
34 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfTrace
;
35 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTrace
;
36 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.experiment
.TmfExperiment
;
37 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.analysis
.AnalysisRequirementFactory
;
38 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.analysis
.TestAnalysis
;
39 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.analysis
.TestAnalysis2
;
40 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
41 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.trace
.TmfTraceStub2
;
42 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.trace
.TmfTraceStub3
;
43 import org
.junit
.After
;
44 import org
.junit
.Before
;
45 import org
.junit
.Test
;
46 import org
.osgi
.framework
.Bundle
;
48 import com
.google
.common
.collect
.ImmutableSet
;
49 import com
.google
.common
.collect
.Multimap
;
52 * Test suite for the {@link TmfAnalysisModuleHelperConfigElement} class
54 * @author Geneviève Bastien
56 public class AnalysisModuleHelperTest
{
58 private IAnalysisModuleHelper fModule
;
59 private IAnalysisModuleHelper fModuleOther
;
60 private IAnalysisModuleHelper fReqModule
;
61 private ITmfTrace fTrace
;
63 private static IAnalysisModuleHelper
getModuleHelper(@NonNull String moduleId
) {
64 Multimap
<String
, IAnalysisModuleHelper
> helpers
= TmfAnalysisManager
.getAnalysisModules();
65 assertEquals(1, helpers
.get(moduleId
).size());
66 return helpers
.get(moduleId
).iterator().next();
70 * Gets the module helpers for 2 test modules
73 public void getModules() {
74 fModule
= getModuleHelper(AnalysisManagerTest
.MODULE_PARAM
);
75 assertNotNull(fModule
);
76 assertTrue(fModule
instanceof TmfAnalysisModuleHelperConfigElement
);
77 fModuleOther
= getModuleHelper(AnalysisManagerTest
.MODULE_SECOND
);
78 assertNotNull(fModuleOther
);
79 assertTrue(fModuleOther
instanceof TmfAnalysisModuleHelperConfigElement
);
80 fReqModule
= getModuleHelper(AnalysisManagerTest
.MODULE_REQ
);
81 assertNotNull(fReqModule
);
82 assertTrue(fReqModule
instanceof TmfAnalysisModuleHelperConfigElement
);
83 fTrace
= TmfTestTrace
.A_TEST_10K2
.getTraceAsStub2();
87 * Some tests use traces, let's clean them here
90 public void cleanupTraces() {
91 TmfTestTrace
.A_TEST_10K
.dispose();
96 * Test the helper's getters and setters
99 public void testHelperGetters() {
100 /* With first module */
101 assertEquals(AnalysisManagerTest
.MODULE_PARAM
, fModule
.getId());
102 assertEquals("Test analysis", fModule
.getName());
103 assertFalse(fModule
.isAutomatic());
105 Bundle helperbundle
= fModule
.getBundle();
106 Bundle thisbundle
= Platform
.getBundle("org.eclipse.tracecompass.tmf.core.tests");
107 assertNotNull(helperbundle
);
108 assertEquals(thisbundle
, helperbundle
);
110 /* With other module */
111 assertEquals(AnalysisManagerTest
.MODULE_SECOND
, fModuleOther
.getId());
112 assertEquals("Test other analysis", fModuleOther
.getName());
113 assertTrue(fModuleOther
.isAutomatic());
118 * {@link TmfAnalysisModuleHelperConfigElement#appliesToTraceType(Class)}
119 * method for the 2 modules
122 public void testAppliesToTrace() {
124 assertFalse(fModule
.appliesToTraceType(TmfTrace
.class));
125 assertTrue(fModule
.appliesToTraceType(TmfTraceStub
.class));
126 assertTrue(fModule
.appliesToTraceType(TmfTraceStub2
.class));
127 assertFalse(fModule
.appliesToTraceType(TmfTraceStub3
.class));
128 assertFalse(fModule
.appliesToTraceType(TmfExperiment
.class));
131 assertFalse(fModuleOther
.appliesToTraceType(TmfTrace
.class));
132 assertFalse(fModuleOther
.appliesToTraceType(TmfTraceStub
.class));
133 assertTrue(fModuleOther
.appliesToTraceType(TmfTraceStub2
.class));
134 assertTrue(fModuleOther
.appliesToTraceType(TmfTraceStub3
.class));
135 assertTrue(fModuleOther
.appliesToTraceType(TmfExperiment
.class));
140 * {@link TmfAnalysisModuleHelperConfigElement#newModule(ITmfTrace)} method
144 public void testNewModule() {
145 /* Test analysis module with traceStub */
146 IAnalysisModule module
= null;
148 module
= fModule
.newModule(TmfTestTrace
.A_TEST_10K
.getTrace());
149 assertNotNull(module
);
150 assertTrue(module
instanceof TestAnalysis
);
151 } catch (TmfAnalysisException e
) {
154 if (module
!= null) {
159 /* TestAnalysis2 module with trace, should return an exception */
161 module
= fModuleOther
.newModule(TmfTestTrace
.A_TEST_10K
.getTrace());
163 } catch (TmfAnalysisException e
) {
166 if (module
!= null) {
171 /* TestAnalysis2 module with a TraceStub2 */
172 ITmfTrace trace
= fTrace
;
173 assertNotNull(trace
);
175 module
= fModuleOther
.newModule(trace
);
176 assertNotNull(module
);
177 assertTrue(module
instanceof TestAnalysis2
);
178 } catch (TmfAnalysisException e
) {
181 if (module
!= null) {
189 * Test the analysis modules with a differing result for experiments
192 public void testAppliesToExperiment() {
193 ITmfTrace trace1
= TmfTestTrace
.A_TEST_10K
.getTrace();
194 ITmfTrace trace2
= TmfTestTrace
.A_TEST_10K2
.getTrace();
195 ITmfTrace trace3
= TmfTestTrace
.A_TEST_10K2
.getTraceAsStub2();
197 /* Create an experiment with TmfTraceStub */
198 ITmfTrace
[] tracesExp1
= { trace1
, trace2
};
199 TmfExperiment exp1
= new TmfExperiment(tracesExp1
[0].getEventType(), "Experiment 1", tracesExp1
, TmfExperiment
.DEFAULT_INDEX_PAGE_SIZE
, null);
201 /* Create an experiment containing some TmfTraceStub2 */
202 ITmfTrace
[] tracesExp2
= { trace1
, trace3
};
203 TmfExperiment exp2
= new TmfExperiment(tracesExp2
[0].getEventType(), "Experiment 1", tracesExp2
, TmfExperiment
.DEFAULT_INDEX_PAGE_SIZE
, null);
207 /* fModule should return null for both experiments */
208 IAnalysisModule module
= null;
210 module
= fModule
.newModule(exp1
);
212 } catch (TmfAnalysisException e
) {
215 if (module
!= null) {
221 module
= fModule
.newModule(exp2
);
223 } catch (TmfAnalysisException e
) {
226 if (module
!= null) {
231 /* fModuleOther should throw exception for exp1, but not exp2 */
233 module
= fModuleOther
.newModule(exp1
);
235 } catch (TmfAnalysisException e
) {
238 if (module
!= null) {
244 module
= fModuleOther
.newModule(exp2
);
245 assertNotNull(module
);
246 } catch (TmfAnalysisException e
) {
249 if (module
!= null) {
261 * Test for the initialization of parameters from the extension points
264 public void testParameters() {
265 ITmfTrace trace
= TmfTestTrace
.A_TEST_10K
.getTrace();
268 * This analysis has a parameter, but no default value. we should be
269 * able to set the parameter
271 IAnalysisModuleHelper helper
= getModuleHelper(AnalysisManagerTest
.MODULE_PARAM
);
272 assertNotNull(helper
);
273 IAnalysisModule module
= null;
275 module
= helper
.newModule(trace
);
276 assertNotNull(module
);
277 assertNull(module
.getParameter(TestAnalysis
.PARAM_TEST
));
278 module
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
279 assertEquals(1, module
.getParameter(TestAnalysis
.PARAM_TEST
));
281 } catch (TmfAnalysisException e1
) {
282 fail(e1
.getMessage());
285 if (module
!= null) {
290 /* This module has a parameter with default value */
291 helper
= getModuleHelper(AnalysisManagerTest
.MODULE_PARAM_DEFAULT
);
292 assertNotNull(helper
);
294 module
= helper
.newModule(trace
);
295 assertNotNull(module
);
296 assertEquals(3, module
.getParameter(TestAnalysis
.PARAM_TEST
));
297 module
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
298 assertEquals(1, module
.getParameter(TestAnalysis
.PARAM_TEST
));
300 } catch (TmfAnalysisException e1
) {
301 fail(e1
.getMessage());
304 if (module
!= null) {
310 * This module does not have a parameter so setting it should throw an
313 helper
= getModuleHelper(AnalysisManagerTest
.MODULE_SECOND
);
314 assertNotNull(helper
);
315 Exception exception
= null;
317 assertNotNull(trace
);
319 module
= helper
.newModule(trace
);
320 assertNotNull(module
);
321 assertNull(module
.getParameter(TestAnalysis
.PARAM_TEST
));
324 module
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
325 } catch (RuntimeException e
) {
328 } catch (TmfAnalysisException e1
) {
329 fail(e1
.getMessage());
332 if (module
!= null) {
336 assertNotNull(exception
);
341 * {@link TmfAnalysisModuleHelperConfigElement#getValidTraceTypes} method
344 public void testGetValidTraceTypes() {
345 Set
<Class
<?
extends ITmfTrace
>> expected
= ImmutableSet
.of((Class
<?
extends ITmfTrace
>) TmfTraceStub
.class, TmfTraceStub2
.class, TmfTraceStub3
.class);
346 Iterable
<Class
<?
extends ITmfTrace
>> traceTypes
= fReqModule
.getValidTraceTypes();
347 assertEquals(expected
, traceTypes
);
352 * {@link TmfAnalysisModuleHelperConfigElement#getAnalysisRequirements}
356 public void testGetRequirements() {
357 Iterable
<TmfAbstractAnalysisRequirement
> requirements
= fReqModule
.getAnalysisRequirements();
358 Set
<TmfAbstractAnalysisRequirement
> expected
= ImmutableSet
.of(
359 AnalysisRequirementFactory
.REQUIREMENT_1
,
360 AnalysisRequirementFactory
.REQUIREMENT_3
);
362 assertEquals(expected
, requirements
);