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.HashMap;
  24 import java.util.Map;
  25 import java.util.Set;
  26
  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;
  51
  52 import com.google.common.collect.ImmutableSet;
  53 import com.google.common.collect.Multimap;
  54
  55 /**
  56  * Test suite for the {@link TmfAnalysisModuleHelperConfigElement} class
  57  *
  58  * @author Geneviève Bastien
  59  */
  60 public class AnalysisModuleHelperTest {
  61
  62     private IAnalysisModuleHelper fModule;
  63     private IAnalysisModuleHelper fModuleOther;
  64     private IAnalysisModuleHelper fReqModule;
  65     private ITmfTrace fTrace;
  66
  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();
  71     }
  72
  73     /**
  74      * Gets the module helpers for 2 test modules
  75      */
  76     @Before
  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();
  88     }
  89
  90     /**
  91      * Some tests use traces, let's clean them here
  92      */
  93     @After
  94     public void cleanupTraces() {
  95         TmfTestTrace.A_TEST_10K.dispose();
  96         fTrace.dispose();
  97     }
  98
  99     /**
 100      * Test the helper's getters and setters
 101      */
 102     @Test
 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());
 108
 109         Bundle helperbundle = fModule.getBundle();
 110         Bundle thisbundle = Platform.getBundle("org.eclipse.tracecompass.tmf.core.tests");
 111         assertNotNull(helperbundle);
 112         assertEquals(thisbundle, helperbundle);
 113
 114         /* With other module */
 115         assertEquals(AnalysisManagerTest.MODULE_SECOND, fModuleOther.getId());
 116         assertEquals("Test other analysis", fModuleOther.getName());
 117         assertTrue(fModuleOther.isAutomatic());
 118     }
 119
 120     /**
 121      * Test the
 122      * {@link TmfAnalysisModuleHelperConfigElement#appliesToTraceType(Class)}
 123      * method for the 2 modules
 124      */
 125     @Test
 126     public void testAppliesToTrace() {
 127         /* stub module */
 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));
 133
 134         /* stub module 2 */
 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));
 140     }
 141
 142     /**
 143      * Test the
 144      * {@link TmfAnalysisModuleHelperConfigElement#newModule(ITmfTrace)} method
 145      * for the 2 modules
 146      */
 147     @Test
 148     public void testNewModule() {
 149         /* Test analysis module with traceStub */
 150         Exception exception = null;
 151         IAnalysisModule module = null;
 152         try {
 153             module = fModule.newModule(TmfTestTrace.A_TEST_10K.getTrace());
 154             assertNotNull(module);
 155             assertTrue(module instanceof TestAnalysis);
 156         } catch (TmfAnalysisException e) {
 157             exception = e;
 158         } finally {
 159             if (module != null) {
 160                 module.dispose();
 161             }
 162         }
 163         assertNull(exception);
 164
 165         /* TestAnalysis2 module with trace, should return an exception */
 166         try {
 167             module = fModuleOther.newModule(TmfTestTrace.A_TEST_10K.getTrace());
 168         } catch (TmfAnalysisException e) {
 169             exception = e;
 170         } finally {
 171             if (module != null) {
 172                 module.dispose();
 173             }
 174         }
 175         assertNotNull(exception);
 176         assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModuleOther.getName()), exception.getMessage());
 177
 178         /* TestAnalysis2 module with a TraceStub2 */
 179         exception = null;
 180         ITmfTrace trace = fTrace;
 181         assertNotNull(trace);
 182         try {
 183             module = fModuleOther.newModule(trace);
 184             assertNotNull(module);
 185             assertTrue(module instanceof TestAnalysis2);
 186         } catch (TmfAnalysisException e) {
 187             exception = e;
 188         } finally {
 189             if (module != null) {
 190                 module.dispose();
 191             }
 192         }
 193         assertNull(exception);
 194     }
 195
 196
 197     /**
 198      * Test the analysis modules with a differing result for experiments
 199      */
 200     @Test
 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();
 205
 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);
 209
 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);
 213
 214         try {
 215
 216             /* fModule should throw exception for both experiments */
 217             Exception exception = null;
 218             IAnalysisModule module = null;
 219             try {
 220                 module = fModule.newModule(exp1);
 221             } catch (TmfAnalysisException e) {
 222                 exception = e;
 223             } finally {
 224                 if (module != null) {
 225                     module.dispose();
 226                 }
 227             }
 228             assertNotNull(exception);
 229             assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModule.getName()), exception.getMessage());
 230
 231             exception = null;
 232             try {
 233                 module = fModule.newModule(exp2);
 234             } catch (TmfAnalysisException e) {
 235                 exception = e;
 236             } finally {
 237                 if (module != null) {
 238                     module.dispose();
 239                 }
 240             }
 241             assertNotNull(exception);
 242             assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModule.getName()), exception.getMessage());
 243
 244             /* fModuleOther should throw exception for exp1, but not exp2 */
 245             exception = null;
 246             try {
 247                 module = fModuleOther.newModule(exp1);
 248             } catch (TmfAnalysisException e) {
 249                 exception = e;
 250             } finally {
 251                 if (module != null) {
 252                     module.dispose();
 253                 }
 254             }
 255             assertNotNull(exception);
 256             assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModuleOther.getName()), exception.getMessage());
 257
 258             exception = null;
 259             try {
 260                 module = fModuleOther.newModule(exp2);
 261                 assertNotNull(module);
 262             } catch (TmfAnalysisException e) {
 263                 exception = e;
 264             } finally {
 265                 if (module != null) {
 266                     module.dispose();
 267                 }
 268             }
 269             assertNull(exception);
 270
 271         } finally {
 272             exp2.dispose();
 273             exp1.dispose();
 274         }
 275     }
 276
 277     /**
 278      * Test for the initialization of parameters from the extension points
 279      */
 280     @Test
 281     public void testParameters() {
 282         ITmfTrace trace = TmfTestTrace.A_TEST_10K.getTrace();
 283
 284         /*
 285          * This analysis has a parameter, but no default value. we should be
 286          * able to set the parameter
 287          */
 288         IAnalysisModuleHelper helper = getModuleHelper(AnalysisManagerTest.MODULE_PARAM);
 289         assertNotNull(helper);
 290         IAnalysisModule module = null;
 291         try {
 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));
 296
 297         } catch (TmfAnalysisException e1) {
 298             fail(e1.getMessage());
 299             return;
 300         } finally {
 301             if (module != null) {
 302                 module.dispose();
 303             }
 304         }
 305
 306         /* This module has a parameter with default value */
 307         helper = getModuleHelper(AnalysisManagerTest.MODULE_PARAM_DEFAULT);
 308         assertNotNull(helper);
 309         try {
 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));
 314
 315         } catch (TmfAnalysisException e1) {
 316             fail(e1.getMessage());
 317             return;
 318         } finally {
 319             if (module != null) {
 320                 module.dispose();
 321             }
 322         }
 323
 324         /*
 325          * This module does not have a parameter so setting it should throw an
 326          * error
 327          */
 328         helper = getModuleHelper(AnalysisManagerTest.MODULE_SECOND);
 329         assertNotNull(helper);
 330         Exception exception = null;
 331         trace = fTrace;
 332         assertNotNull(trace);
 333         try {
 334             module = helper.newModule(trace);
 335             assertNull(module.getParameter(TestAnalysis.PARAM_TEST));
 336
 337             try {
 338                 module.setParameter(TestAnalysis.PARAM_TEST, 1);
 339             } catch (RuntimeException e) {
 340                 exception = e;
 341             }
 342         } catch (TmfAnalysisException e1) {
 343             fail(e1.getMessage());
 344             return;
 345         } finally {
 346             if (module != null) {
 347                 module.dispose();
 348             }
 349         }
 350         assertNotNull(exception);
 351     }
 352
 353     /**
 354      * Test for the
 355      * {@link TmfAnalysisModuleHelperConfigElement#getValidTraceTypes} method
 356      */
 357     @Test
 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);
 362     }
 363
 364     /**
 365      * Test for the
 366      * {@link TmfAnalysisModuleHelperConfigElement#getAnalysisRequirements}
 367      * method
 368      */
 369     @Test
 370     public void testGetRequirements() {
 371         Iterable<TmfAnalysisRequirement> requirements = fReqModule.getAnalysisRequirements();
 372         assertNotNull(requirements);
 373
 374         Map<String, TmfAnalysisRequirement> rMap = new HashMap<>();
 375
 376         for (TmfAnalysisRequirement req : requirements) {
 377             assertFalse(rMap.containsKey(req.getType()));
 378             rMap.put(req.getType(), req);
 379         }
 380         assertEquals(2, rMap.size());
 381
 382         /* Test if all types and values have been obtained */
 383         TmfAnalysisRequirement req = rMap.get(TestRequirementAnalysis.EVENT_TYPE);
 384         assertNotNull(req);
 385
 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));
 391
 392         req = rMap.get(TestRequirementAnalysis.FIELD_TYPE);
 393         assertNotNull(req);
 394
 395         values = req.getValues();
 396         assertEquals(2, values.size());
 397         assertTrue(values.contains(TestRequirementAnalysis.PID));
 398         assertTrue(values.contains(TestRequirementAnalysis.TID));
 399     }
 400 }