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.osgi.util.NLS;
  29 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
  30 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModuleHelper;
  31 import org.eclipse.tracecompass.tmf.core.analysis.Messages;
  32 import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisManager;
  33 import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisModuleHelperConfigElement;
  34 import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement;
  35 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
  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.core.trace.TmfTrace;
  39 import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis;
  40 import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis2;
  41 import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestRequirementAnalysis;
  42 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
  43 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub2;
  44 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub3;
  45 import org.junit.After;
  46 import org.junit.Before;
  47 import org.junit.Test;
  48 import org.osgi.framework.Bundle;
  49
  50 import com.google.common.collect.ImmutableSet;
  51
  52 /**
  53  * Test suite for the {@link TmfAnalysisModuleHelperConfigElement} class
  54  *
  55  * @author Geneviève Bastien
  56  */
  57 public class AnalysisModuleHelperTest {
  58
  59     private IAnalysisModuleHelper fModule;
  60     private IAnalysisModuleHelper fModuleOther;
  61     private IAnalysisModuleHelper fReqModule;
  62     private ITmfTrace fTrace;
  63
  64     /**
  65      * Gets the module helpers for 2 test modules
  66      */
  67     @Before
  68     public void getModules() {
  69         fModule = TmfAnalysisManager.getAnalysisModule(AnalysisManagerTest.MODULE_PARAM);
  70         assertNotNull(fModule);
  71         assertTrue(fModule instanceof TmfAnalysisModuleHelperConfigElement);
  72         fModuleOther = TmfAnalysisManager.getAnalysisModule(AnalysisManagerTest.MODULE_SECOND);
  73         assertNotNull(fModuleOther);
  74         assertTrue(fModuleOther instanceof TmfAnalysisModuleHelperConfigElement);
  75         fReqModule = TmfAnalysisManager.getAnalysisModule(AnalysisManagerTest.MODULE_REQ);
  76         assertNotNull(fReqModule);
  77         assertTrue(fReqModule instanceof TmfAnalysisModuleHelperConfigElement);
  78         fTrace = TmfTestTrace.A_TEST_10K2.getTraceAsStub2();
  79     }
  80
  81     /**
  82      * Some tests use traces, let's clean them here
  83      */
  84     @After
  85     public void cleanupTraces() {
  86         TmfTestTrace.A_TEST_10K.dispose();
  87         fTrace.dispose();
  88     }
  89
  90     /**
  91      * Test the helper's getters and setters
  92      */
  93     @Test
  94     public void testHelperGetters() {
  95         /* With first module */
  96         assertEquals(AnalysisManagerTest.MODULE_PARAM, fModule.getId());
  97         assertEquals("Test analysis", fModule.getName());
  98         assertFalse(fModule.isAutomatic());
  99
 100         Bundle helperbundle = fModule.getBundle();
 101         Bundle thisbundle = Platform.getBundle("org.eclipse.tracecompass.tmf.core.tests");
 102         assertNotNull(helperbundle);
 103         assertEquals(thisbundle, helperbundle);
 104
 105         /* With other module */
 106         assertEquals(AnalysisManagerTest.MODULE_SECOND, fModuleOther.getId());
 107         assertEquals("Test other analysis", fModuleOther.getName());
 108         assertTrue(fModuleOther.isAutomatic());
 109     }
 110
 111     /**
 112      * Test the
 113      * {@link TmfAnalysisModuleHelperConfigElement#appliesToTraceType(Class)}
 114      * method for the 2 modules
 115      */
 116     @Test
 117     public void testAppliesToTrace() {
 118         /* stub module */
 119         assertFalse(fModule.appliesToTraceType(TmfTrace.class));
 120         assertTrue(fModule.appliesToTraceType(TmfTraceStub.class));
 121         assertTrue(fModule.appliesToTraceType(TmfTraceStub2.class));
 122         assertFalse(fModule.appliesToTraceType(TmfTraceStub3.class));
 123
 124         /* stub module 2 */
 125         assertFalse(fModuleOther.appliesToTraceType(TmfTrace.class));
 126         assertFalse(fModuleOther.appliesToTraceType(TmfTraceStub.class));
 127         assertTrue(fModuleOther.appliesToTraceType(TmfTraceStub2.class));
 128         assertTrue(fModuleOther.appliesToTraceType(TmfTraceStub3.class));
 129     }
 130
 131     /**
 132      * Test the
 133      * {@link TmfAnalysisModuleHelperConfigElement#newModule(ITmfTrace)} method
 134      * for the 2 modules
 135      */
 136     @Test
 137     public void testNewModule() {
 138         /* Test analysis module with traceStub */
 139         Exception exception = null;
 140         IAnalysisModule module = null;
 141         try {
 142             module = fModule.newModule(TmfTestTrace.A_TEST_10K.getTrace());
 143             assertNotNull(module);
 144             assertTrue(module instanceof TestAnalysis);
 145         } catch (TmfAnalysisException e) {
 146             exception = e;
 147         } finally {
 148             if (module != null) {
 149                 module.dispose();
 150             }
 151         }
 152         assertNull(exception);
 153
 154         /* TestAnalysis2 module with trace, should return an exception */
 155         try {
 156             module = fModuleOther.newModule(TmfTestTrace.A_TEST_10K.getTrace());
 157         } catch (TmfAnalysisException e) {
 158             exception = e;
 159         } finally {
 160             if (module != null) {
 161                 module.dispose();
 162             }
 163         }
 164         assertNotNull(exception);
 165         assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModuleOther.getName()), exception.getMessage());
 166
 167         /* TestAnalysis2 module with a TraceStub2 */
 168         exception = null;
 169         try {
 170             module = fModuleOther.newModule(fTrace);
 171             assertNotNull(module);
 172             assertTrue(module instanceof TestAnalysis2);
 173         } catch (TmfAnalysisException e) {
 174             exception = e;
 175         } finally {
 176             if (module != null) {
 177                 module.dispose();
 178             }
 179         }
 180         assertNull(exception);
 181     }
 182
 183     /**
 184      * Test for the initialization of parameters from the extension points
 185      */
 186     @Test
 187     public void testParameters() {
 188         ITmfTrace trace = TmfTestTrace.A_TEST_10K.getTrace();
 189
 190         /*
 191          * This analysis has a parameter, but no default value. we should be
 192          * able to set the parameter
 193          */
 194         IAnalysisModuleHelper helper = TmfAnalysisManager.getAnalysisModule(AnalysisManagerTest.MODULE_PARAM);
 195         IAnalysisModule module = null;
 196         try {
 197             module = helper.newModule(trace);
 198             assertNull(module.getParameter(TestAnalysis.PARAM_TEST));
 199             module.setParameter(TestAnalysis.PARAM_TEST, 1);
 200             assertEquals(1, module.getParameter(TestAnalysis.PARAM_TEST));
 201
 202         } catch (TmfAnalysisException e1) {
 203             fail(e1.getMessage());
 204             return;
 205         } finally {
 206             if (module != null) {
 207                 module.dispose();
 208             }
 209         }
 210
 211         /* This module has a parameter with default value */
 212         helper = TmfAnalysisManager.getAnalysisModule(AnalysisManagerTest.MODULE_PARAM_DEFAULT);
 213         try {
 214             module = helper.newModule(trace);
 215             assertEquals(3, module.getParameter(TestAnalysis.PARAM_TEST));
 216             module.setParameter(TestAnalysis.PARAM_TEST, 1);
 217             assertEquals(1, module.getParameter(TestAnalysis.PARAM_TEST));
 218
 219         } catch (TmfAnalysisException e1) {
 220             fail(e1.getMessage());
 221             return;
 222         } finally {
 223             if (module != null) {
 224                 module.dispose();
 225             }
 226         }
 227
 228         /*
 229          * This module does not have a parameter so setting it should throw an
 230          * error
 231          */
 232         helper = TmfAnalysisManager.getAnalysisModule(AnalysisManagerTest.MODULE_SECOND);
 233         Exception exception = null;
 234         try {
 235             module = helper.newModule(fTrace);
 236             assertNull(module.getParameter(TestAnalysis.PARAM_TEST));
 237
 238             try {
 239                 module.setParameter(TestAnalysis.PARAM_TEST, 1);
 240             } catch (RuntimeException e) {
 241                 exception = e;
 242             }
 243         } catch (TmfAnalysisException e1) {
 244             fail(e1.getMessage());
 245             return;
 246         } finally {
 247             if (module != null) {
 248                 module.dispose();
 249             }
 250         }
 251         assertNotNull(exception);
 252     }
 253
 254     /**
 255      * Test for the
 256      * {@link TmfAnalysisModuleHelperConfigElement#getValidTraceTypes} method
 257      */
 258     @Test
 259     public void testGetValidTraceTypes() {
 260         Set<Class<? extends ITmfTrace>> expected = ImmutableSet.of((Class<? extends ITmfTrace>) TmfTraceStub.class, TmfTraceStub2.class, TmfTraceStub3.class);
 261         Iterable<Class<? extends ITmfTrace>> traceTypes = fReqModule.getValidTraceTypes();
 262         assertEquals(expected, traceTypes);
 263     }
 264
 265     /**
 266      * Test for the
 267      * {@link TmfAnalysisModuleHelperConfigElement#getAnalysisRequirements}
 268      * method
 269      */
 270     @Test
 271     public void testGetRequirements() {
 272         Iterable<TmfAnalysisRequirement> requirements = fReqModule.getAnalysisRequirements();
 273         assertNotNull(requirements);
 274
 275         Map<String, TmfAnalysisRequirement> rMap = new HashMap<>();
 276
 277         for (TmfAnalysisRequirement req : requirements) {
 278             assertFalse(rMap.containsKey(req.getType()));
 279             rMap.put(req.getType(), req);
 280         }
 281         assertEquals(2, rMap.size());
 282
 283         /* Test if all types and values have been obtained */
 284         TmfAnalysisRequirement req = rMap.get(TestRequirementAnalysis.EVENT_TYPE);
 285         assertNotNull(req);
 286
 287         Set<String> values = req.getValues();
 288         assertEquals(3, values.size());
 289         assertTrue(values.contains(TestRequirementAnalysis.EXIT_SYSCALL));
 290         assertTrue(values.contains(TestRequirementAnalysis.SCHED_SWITCH));
 291         assertTrue(values.contains(TestRequirementAnalysis.SCHED_WAKEUP));
 292
 293         req = rMap.get(TestRequirementAnalysis.FIELD_TYPE);
 294         assertNotNull(req);
 295
 296         values = req.getValues();
 297         assertEquals(2, values.size());
 298         assertTrue(values.contains(TestRequirementAnalysis.PID));
 299         assertTrue(values.contains(TestRequirementAnalysis.TID));
 300     }
 301 }