tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleHelperTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2014 École Polytechnique de Montréal
   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  *   Geneviève Bastien - Initial API and implementation
  11  *   Mathieu Rail - Added tests for getting a module's requirements
  12  *******************************************************************************/
  13
  14 package org.eclipse.tracecompass.tmf.core.tests.analysis;
  15
  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;
  22
  23 import java.util.Set;
  24
  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;
  47
  48 import com.google.common.collect.ImmutableSet;
  49 import com.google.common.collect.Multimap;
  50
  51 /**
  52  * Test suite for the {@link TmfAnalysisModuleHelperConfigElement} class
  53  *
  54  * @author Geneviève Bastien
  55  */
  56 public class AnalysisModuleHelperTest {
  57
  58     private IAnalysisModuleHelper fModule;
  59     private IAnalysisModuleHelper fModuleOther;
  60     private IAnalysisModuleHelper fReqModule;
  61     private ITmfTrace fTrace;
  62
  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();
  67     }
  68
  69     /**
  70      * Gets the module helpers for 2 test modules
  71      */
  72     @Before
  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();
  84     }
  85
  86     /**
  87      * Some tests use traces, let's clean them here
  88      */
  89     @After
  90     public void cleanupTraces() {
  91         TmfTestTrace.A_TEST_10K.dispose();
  92         fTrace.dispose();
  93     }
  94
  95     /**
  96      * Test the helper's getters and setters
  97      */
  98     @Test
  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());
 104
 105         Bundle helperbundle = fModule.getBundle();
 106         Bundle thisbundle = Platform.getBundle("org.eclipse.tracecompass.tmf.core.tests");
 107         assertNotNull(helperbundle);
 108         assertEquals(thisbundle, helperbundle);
 109
 110         /* With other module */
 111         assertEquals(AnalysisManagerTest.MODULE_SECOND, fModuleOther.getId());
 112         assertEquals("Test other analysis", fModuleOther.getName());
 113         assertTrue(fModuleOther.isAutomatic());
 114     }
 115
 116     /**
 117      * Test the
 118      * {@link TmfAnalysisModuleHelperConfigElement#appliesToTraceType(Class)}
 119      * method for the 2 modules
 120      */
 121     @Test
 122     public void testAppliesToTrace() {
 123         /* stub module */
 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));
 129
 130         /* stub module 2 */
 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         assertFalse(fModuleOther.appliesToTraceType(TmfExperiment.class));
 136     }
 137
 138     /**
 139      * Test the
 140      * {@link TmfAnalysisModuleHelperConfigElement#newModule(ITmfTrace)} method
 141      * for the 2 modules
 142      */
 143     @Test
 144     public void testNewModule() {
 145         /* Test analysis module with traceStub */
 146         IAnalysisModule module = null;
 147         try {
 148             module = fModule.newModule(TmfTestTrace.A_TEST_10K.getTrace());
 149             assertNotNull(module);
 150             assertTrue(module instanceof TestAnalysis);
 151         } catch (TmfAnalysisException e) {
 152             fail();
 153         } finally {
 154             if (module != null) {
 155                 module.dispose();
 156             }
 157         }
 158
 159         /* TestAnalysis2 module with trace, should return an exception */
 160         try {
 161             module = fModuleOther.newModule(TmfTestTrace.A_TEST_10K.getTrace());
 162             assertNull(module);
 163         } catch (TmfAnalysisException e) {
 164             fail();
 165         } finally {
 166             if (module != null) {
 167                 module.dispose();
 168             }
 169         }
 170
 171         /* TestAnalysis2 module with a TraceStub2 */
 172         ITmfTrace trace = fTrace;
 173         assertNotNull(trace);
 174         try {
 175             module = fModuleOther.newModule(trace);
 176             assertNotNull(module);
 177             assertTrue(module instanceof TestAnalysis2);
 178         } catch (TmfAnalysisException e) {
 179             fail();
 180         } finally {
 181             if (module != null) {
 182                 module.dispose();
 183             }
 184         }
 185     }
 186
 187
 188     /**
 189      * Test the analysis modules with a differing result for experiments
 190      */
 191     @Test
 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();
 196
 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);
 200
 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);
 204
 205         try {
 206
 207             /* fModule should return null for both experiments */
 208             IAnalysisModule module = null;
 209             try {
 210                 module = fModule.newModule(exp1);
 211                 assertNull(module);
 212             } catch (TmfAnalysisException e) {
 213                 fail();
 214             } finally {
 215                 if (module != null) {
 216                     module.dispose();
 217                 }
 218             }
 219
 220             try {
 221                 module = fModule.newModule(exp2);
 222                 assertNull(module);
 223             } catch (TmfAnalysisException e) {
 224                 fail();
 225             } finally {
 226                 if (module != null) {
 227                     module.dispose();
 228                 }
 229             }
 230
 231             /* fModuleOther should throw exception for exp1, but not exp2 */
 232             try {
 233                 module = fModuleOther.newModule(exp1);
 234                 assertNull(module);
 235             } catch (TmfAnalysisException e) {
 236                 fail();
 237             } finally {
 238                 if (module != null) {
 239                     module.dispose();
 240                 }
 241             }
 242
 243             try {
 244                 module = fModuleOther.newModule(exp2);
 245                 assertNotNull(module);
 246             } catch (TmfAnalysisException e) {
 247                 fail();
 248             } finally {
 249                 if (module != null) {
 250                     module.dispose();
 251                 }
 252             }
 253
 254         } finally {
 255             exp2.dispose();
 256             exp1.dispose();
 257         }
 258     }
 259
 260     /**
 261      * Test for the initialization of parameters from the extension points
 262      */
 263     @Test
 264     public void testParameters() {
 265         ITmfTrace trace = TmfTestTrace.A_TEST_10K.getTrace();
 266
 267         /*
 268          * This analysis has a parameter, but no default value. we should be
 269          * able to set the parameter
 270          */
 271         IAnalysisModuleHelper helper = getModuleHelper(AnalysisManagerTest.MODULE_PARAM);
 272         assertNotNull(helper);
 273         IAnalysisModule module = null;
 274         try {
 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));
 280
 281         } catch (TmfAnalysisException e1) {
 282             fail(e1.getMessage());
 283             return;
 284         } finally {
 285             if (module != null) {
 286                 module.dispose();
 287             }
 288         }
 289
 290         /* This module has a parameter with default value */
 291         helper = getModuleHelper(AnalysisManagerTest.MODULE_PARAM_DEFAULT);
 292         assertNotNull(helper);
 293         try {
 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));
 299
 300         } catch (TmfAnalysisException e1) {
 301             fail(e1.getMessage());
 302             return;
 303         } finally {
 304             if (module != null) {
 305                 module.dispose();
 306             }
 307         }
 308
 309         /*
 310          * This module does not have a parameter so setting it should throw an
 311          * error
 312          */
 313         helper = getModuleHelper(AnalysisManagerTest.MODULE_SECOND);
 314         assertNotNull(helper);
 315         Exception exception = null;
 316         trace = fTrace;
 317         assertNotNull(trace);
 318         try {
 319             module = helper.newModule(trace);
 320             assertNotNull(module);
 321             assertNull(module.getParameter(TestAnalysis.PARAM_TEST));
 322
 323             try {
 324                 module.setParameter(TestAnalysis.PARAM_TEST, 1);
 325             } catch (RuntimeException e) {
 326                 exception = e;
 327             }
 328         } catch (TmfAnalysisException e1) {
 329             fail(e1.getMessage());
 330             return;
 331         } finally {
 332             if (module != null) {
 333                 module.dispose();
 334             }
 335         }
 336         assertNotNull(exception);
 337     }
 338
 339     /**
 340      * Test for the
 341      * {@link TmfAnalysisModuleHelperConfigElement#getValidTraceTypes} method
 342      */
 343     @Test
 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);
 348     }
 349
 350     /**
 351      * Test for the
 352      * {@link TmfAnalysisModuleHelperConfigElement#getAnalysisRequirements}
 353      * method
 354      */
 355     @Test
 356     public void testGetRequirements() {
 357         Iterable<TmfAbstractAnalysisRequirement> requirements = fReqModule.getAnalysisRequirements();
 358         Set<TmfAbstractAnalysisRequirement> expected = ImmutableSet.of(
 359                 AnalysisRequirementFactory.REQUIREMENT_1,
 360                 AnalysisRequirementFactory.REQUIREMENT_3);
 361
 362         assertEquals(expected, requirements);
 363     }
 364 }