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 *******************************************************************************/
13 package org
.eclipse
.tracecompass
.tmf
.core
.tests
.analysis
;
15 import static org
.junit
.Assert
.assertEquals
;
16 import static org
.junit
.Assert
.assertFalse
;
17 import static org
.junit
.Assert
.assertNotNull
;
18 import static org
.junit
.Assert
.assertNull
;
19 import static org
.junit
.Assert
.assertTrue
;
20 import static org
.junit
.Assert
.fail
;
22 import java
.util
.HashSet
;
24 import java
.util
.concurrent
.TimeUnit
;
26 import org
.eclipse
.core
.runtime
.IProgressMonitor
;
27 import org
.eclipse
.core
.runtime
.IStatus
;
28 import org
.eclipse
.core
.runtime
.Status
;
29 import org
.eclipse
.jdt
.annotation
.NonNull
;
30 import org
.eclipse
.osgi
.util
.NLS
;
31 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.IAnalysisModule
;
32 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.Messages
;
33 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.TmfAbstractAnalysisModule
;
34 import org
.eclipse
.tracecompass
.tmf
.core
.exceptions
.TmfAnalysisException
;
35 import org
.eclipse
.tracecompass
.tmf
.core
.tests
.shared
.TmfTestHelper
;
36 import org
.eclipse
.tracecompass
.tmf
.core
.tests
.shared
.TmfTestTrace
;
37 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfTrace
;
38 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.analysis
.TestAnalysis
;
39 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.analysis
.TestAnalysis2
;
40 import org
.junit
.After
;
41 import org
.junit
.Rule
;
42 import org
.junit
.Test
;
43 import org
.junit
.rules
.TestRule
;
44 import org
.junit
.rules
.Timeout
;
46 import com
.google
.common
.collect
.ImmutableSet
;
49 * Test suite for the {@link TmfAbstractAnalysisModule} class
51 public class AnalysisModuleTest
{
55 public TestRule timeoutRule
= new Timeout(30, TimeUnit
.SECONDS
);
57 private static final @NonNull String MODULE_GENERIC_ID
= "test.id";
58 private static final @NonNull String MODULE_GENERIC_NAME
= "Test analysis";
61 * Some tests use traces, let's clean them here
64 public void cleanupTraces() {
65 TmfTestTrace
.A_TEST_10K
.dispose();
69 * Test suite for analysis module getters and setters
72 public void testGettersSetters() {
73 IAnalysisModule module
= new TestAnalysis();
75 module
.setName(MODULE_GENERIC_NAME
);
76 module
.setId(MODULE_GENERIC_ID
);
77 assertEquals(MODULE_GENERIC_ID
, module
.getId());
78 assertEquals(MODULE_GENERIC_NAME
, module
.getName());
80 module
.setAutomatic(false);
81 assertFalse(module
.isAutomatic());
82 module
.setAutomatic(true);
83 assertTrue(module
.isAutomatic());
84 module
.addParameter(TestAnalysis
.PARAM_TEST
);
85 assertNull(module
.getParameter(TestAnalysis
.PARAM_TEST
));
86 module
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
87 assertEquals(1, module
.getParameter(TestAnalysis
.PARAM_TEST
));
89 assertEquals(0, module
.getDependencyLevel());
91 /* Try to set and get wrong parameter */
92 String wrongParam
= "abc";
93 Exception exception
= null;
95 module
.setParameter(wrongParam
, 1);
96 } catch (RuntimeException e
) {
98 assertEquals(NLS
.bind(Messages
.TmfAbstractAnalysisModule_InvalidParameter
, wrongParam
, module
.getName()), e
.getMessage());
100 assertNotNull(exception
);
101 assertNull(module
.getParameter(wrongParam
));
106 private static TestAnalysis
setUpAnalysis() {
107 TestAnalysis module
= new TestAnalysis();
109 module
.setName(MODULE_GENERIC_NAME
);
110 module
.setId(MODULE_GENERIC_ID
);
111 module
.addParameter(TestAnalysis
.PARAM_TEST
);
117 * Test suite for analysis module
118 * {@link TmfAbstractAnalysisModule#waitForCompletion} with successful
122 public void testWaitForCompletionSuccess() {
123 TestAnalysis module
= setUpAnalysis();
125 IStatus status
= module
.schedule();
126 assertEquals(IStatus
.ERROR
, status
.getSeverity());
128 /* Set a stub trace for analysis */
130 assertTrue(module
.setTrace(TmfTestTrace
.A_TEST_10K
.getTrace()));
131 } catch (TmfAnalysisException e
) {
132 fail(e
.getMessage());
135 /* Default execution, with output 1 */
136 module
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
137 status
= module
.schedule();
138 assertEquals(Status
.OK_STATUS
, status
);
139 boolean completed
= module
.waitForCompletion();
141 assertTrue(completed
);
142 assertEquals(1, module
.getAnalysisOutput());
148 * Test suite for {@link TmfAbstractAnalysisModule#waitForCompletion} with
152 public void testWaitForCompletionCancelled() {
153 TestAnalysis module
= setUpAnalysis();
155 /* Set a stub trace for analysis */
156 ITmfTrace trace
= TmfTestTrace
.A_TEST_10K
.getTrace();
158 assertTrue(module
.setTrace(trace
));
159 } catch (TmfAnalysisException e
) {
160 fail(e
.getMessage());
163 module
.setParameter(TestAnalysis
.PARAM_TEST
, 0);
164 IStatus status
= module
.schedule();
165 assertEquals(Status
.OK_STATUS
, status
);
166 boolean completed
= module
.waitForCompletion();
168 assertFalse(completed
);
169 assertEquals(0, module
.getAnalysisOutput());
175 * Test the {@link TmfAbstractAnalysisModule#setTrace(ITmfTrace)} method
179 public void testSetWrongTrace() {
180 IAnalysisModule module
= new TestAnalysis2();
182 module
.setName(MODULE_GENERIC_NAME
);
183 module
.setId(MODULE_GENERIC_ID
);
184 assertEquals(MODULE_GENERIC_ID
, module
.getId());
185 assertEquals(MODULE_GENERIC_NAME
, module
.getName());
188 assertFalse(module
.setTrace(TmfTestTrace
.A_TEST_10K
.getTrace()));
189 } catch (TmfAnalysisException e
) {
197 * Test the {@link TmfAbstractAnalysisModule#setTrace(ITmfTrace)} method
201 public void testSetTraceTwice() {
202 IAnalysisModule module
= new TestAnalysis();
204 module
.setName(MODULE_GENERIC_NAME
);
205 module
.setId(MODULE_GENERIC_ID
);
208 assertTrue(module
.setTrace(TmfTestTrace
.A_TEST_10K
.getTrace()));
209 } catch (TmfAnalysisException e
) {
212 TmfAnalysisException exception
= null;
214 module
.setTrace(TmfTestTrace
.A_TEST_10K
.getTrace());
215 } catch (TmfAnalysisException e
) {
218 assertNotNull(exception
);
224 * Test suite for the {@link TmfAbstractAnalysisModule#cancel()} method
227 public void testCancel() {
228 TestAnalysis module
= setUpAnalysis();
230 module
.setParameter(TestAnalysis
.PARAM_TEST
, 999);
232 assertTrue(module
.setTrace(TmfTestTrace
.A_TEST_10K
.getTrace()));
233 } catch (TmfAnalysisException e
) {
234 fail(e
.getMessage());
237 assertEquals(Status
.OK_STATUS
, module
.schedule());
239 /* Give the job a chance to start */
242 } catch (InterruptedException e
) {
243 fail(e
.getMessage());
247 assertFalse(module
.waitForCompletion());
248 assertEquals(-1, module
.getAnalysisOutput());
254 * Test suite for the {@link IAnalysisModule#notifyParameterChanged(String)}
258 public void testParameterChanged() {
259 TestAnalysis module
= setUpAnalysis();
262 assertTrue(module
.setTrace(TmfTestTrace
.A_TEST_10K
.getTrace()));
263 } catch (TmfAnalysisException e
) {
264 fail(e
.getMessage());
267 /* Check exception if no wrong parameter name */
268 Exception exception
= null;
270 module
.notifyParameterChanged("aaa");
271 } catch (RuntimeException e
) {
274 assertNotNull(exception
);
277 * Cannot test anymore of this method, need a parameter provider to do
284 * Test the {@link TmfTestHelper#executeAnalysis(IAnalysisModule)} method
287 public void testHelper() {
288 TestAnalysis module
= setUpAnalysis();
291 assertTrue(module
.setTrace(TmfTestTrace
.A_TEST_10K
.getTrace()));
292 } catch (TmfAnalysisException e
) {
293 fail(e
.getMessage());
296 module
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
297 boolean res
= TmfTestHelper
.executeAnalysis(module
);
300 module
.setParameter(TestAnalysis
.PARAM_TEST
, 0);
301 res
= TmfTestHelper
.executeAnalysis(module
);
308 * Test the {@link TmfAbstractAnalysisModule} also executes the dependent
312 public void testDependentAnalyses() {
314 ITmfTrace trace
= TmfTestTrace
.A_TEST_10K
.getTrace();
315 int paramAndResult
= 5;
317 /* Setup the dependent module */
318 final String suffix
= " dep";
319 final TestAnalysis depModule
= new TestAnalysis() {
322 protected boolean executeAnalysis(IProgressMonitor monitor
) {
325 } catch (InterruptedException e
) {
328 return super.executeAnalysis(monitor
);
332 depModule
.setName(MODULE_GENERIC_NAME
+ suffix
);
333 depModule
.setId(MODULE_GENERIC_ID
+ suffix
);
334 depModule
.addParameter(TestAnalysis
.PARAM_TEST
);
335 depModule
.setParameter(TestAnalysis
.PARAM_TEST
, paramAndResult
);
337 /* Prepare the main analysis with a dependent analysis */
338 TestAnalysis module
= new TestAnalysis() {
341 protected Iterable
<IAnalysisModule
> getDependentAnalyses() {
342 Set
<IAnalysisModule
> modules
= new HashSet
<>();
343 modules
.add(depModule
);
349 module
.setName(MODULE_GENERIC_NAME
);
350 module
.setId(MODULE_GENERIC_ID
);
351 module
.addParameter(TestAnalysis
.PARAM_TEST
);
352 module
.setParameter(TestAnalysis
.PARAM_TEST
, paramAndResult
);
355 assertTrue(depModule
.setTrace(trace
));
356 assertTrue(module
.setTrace(trace
));
357 } catch (TmfAnalysisException e
) {
358 fail(e
.getMessage());
361 /* Verify none of the module has run */
362 assertEquals(0, module
.getAnalysisOutput());
363 assertEquals(0, depModule
.getAnalysisOutput());
366 assertTrue(module
.waitForCompletion());
367 assertEquals(paramAndResult
, module
.getAnalysisOutput());
369 /* Make sure the dependent analysis has run and completed */
370 assertEquals(paramAndResult
, depModule
.getAnalysisOutput());
372 /* Check the dependency level of both analyses */
373 assertEquals(0, depModule
.getDependencyLevel());
374 assertEquals(1, module
.getDependencyLevel());
383 * Test that the dependency level is consistent with a case where
384 * B depends on A, and C depends on A and B
387 public void testMultipleDependencies() {
389 ITmfTrace trace
= TmfTestTrace
.A_TEST_10K
.getTrace();
391 /* Prepare module A with no dependency */
392 IAnalysisModule moduleA
= new TestAnalysis();
393 moduleA
.setName(MODULE_GENERIC_NAME
);
394 moduleA
.setId(MODULE_GENERIC_ID
);
395 moduleA
.addParameter(TestAnalysis
.PARAM_TEST
);
396 moduleA
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
398 /* Prepare module B depending on A */
399 String suffix
= " B";
400 IAnalysisModule moduleB
= new TestAnalysis() {
403 protected Iterable
<IAnalysisModule
> getDependentAnalyses() {
404 return ImmutableSet
.of(moduleA
);
408 moduleB
.setName(MODULE_GENERIC_NAME
+ suffix
);
409 moduleB
.setId(MODULE_GENERIC_ID
+ suffix
);
410 moduleB
.addParameter(TestAnalysis
.PARAM_TEST
);
411 moduleB
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
413 /* Prepare module C depending on A and B */
415 IAnalysisModule moduleC
= new TestAnalysis() {
418 protected Iterable
<IAnalysisModule
> getDependentAnalyses() {
419 return ImmutableSet
.of(moduleA
, moduleB
);
423 moduleC
.setName(MODULE_GENERIC_NAME
+ suffix
);
424 moduleC
.setId(MODULE_GENERIC_ID
+ suffix
);
425 moduleC
.addParameter(TestAnalysis
.PARAM_TEST
);
426 moduleC
.setParameter(TestAnalysis
.PARAM_TEST
, 1);
429 assertTrue(moduleA
.setTrace(trace
));
430 assertTrue(moduleB
.setTrace(trace
));
431 assertTrue(moduleC
.setTrace(trace
));
432 } catch (TmfAnalysisException e
) {
433 fail(e
.getMessage());
437 assertTrue(moduleC
.waitForCompletion());
439 /* Check the dependency level of the analyses */
440 assertEquals(0, moduleA
.getDependencyLevel());
441 assertEquals(1, moduleB
.getDependencyLevel());
442 assertEquals(3, moduleC
.getDependencyLevel());