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         ITmfTrace trace = fTrace;
 170         assertNotNull(trace);
 171         try {
 172             module = fModuleOther.newModule(trace);
 173             assertNotNull(module);
 174             assertTrue(module instanceof TestAnalysis2);
 175         } catch (TmfAnalysisException e) {
 176             exception = e;
 177         } finally {
 178             if (module != null) {
 179                 module.dispose();
 180             }
 181         }
 182         assertNull(exception);
 183     }
 184
 185     /**
 186      * Test for the initialization of parameters from the extension points
 187      */
 188     @Test
 189     public void testParameters() {
 190         ITmfTrace trace = TmfTestTrace.A_TEST_10K.getTrace();
 191
 192         /*
 193          * This analysis has a parameter, but no default value. we should be
 194          * able to set the parameter
 195          */
 196         IAnalysisModuleHelper helper = TmfAnalysisManager.getAnalysisModule(AnalysisManagerTest.MODULE_PARAM);
 197         assertNotNull(helper);
 198         IAnalysisModule module = null;
 199         try {
 200             module = helper.newModule(trace);
 201             assertNull(module.getParameter(TestAnalysis.PARAM_TEST));
 202             module.setParameter(TestAnalysis.PARAM_TEST, 1);
 203             assertEquals(1, module.getParameter(TestAnalysis.PARAM_TEST));
 204
 205         } catch (TmfAnalysisException e1) {
 206             fail(e1.getMessage());
 207             return;
 208         } finally {
 209             if (module != null) {
 210                 module.dispose();
 211             }
 212         }
 213
 214         /* This module has a parameter with default value */
 215         helper = TmfAnalysisManager.getAnalysisModule(AnalysisManagerTest.MODULE_PARAM_DEFAULT);
 216         assertNotNull(helper);
 217         try {
 218             module = helper.newModule(trace);
 219             assertEquals(3, module.getParameter(TestAnalysis.PARAM_TEST));
 220             module.setParameter(TestAnalysis.PARAM_TEST, 1);
 221             assertEquals(1, module.getParameter(TestAnalysis.PARAM_TEST));
 222
 223         } catch (TmfAnalysisException e1) {
 224             fail(e1.getMessage());
 225             return;
 226         } finally {
 227             if (module != null) {
 228                 module.dispose();
 229             }
 230         }
 231
 232         /*
 233          * This module does not have a parameter so setting it should throw an
 234          * error
 235          */
 236         helper = TmfAnalysisManager.getAnalysisModule(AnalysisManagerTest.MODULE_SECOND);
 237         assertNotNull(helper);
 238         Exception exception = null;
 239         trace = fTrace;
 240         assertNotNull(trace);
 241         try {
 242             module = helper.newModule(trace);
 243             assertNull(module.getParameter(TestAnalysis.PARAM_TEST));
 244
 245             try {
 246                 module.setParameter(TestAnalysis.PARAM_TEST, 1);
 247             } catch (RuntimeException e) {
 248                 exception = e;
 249             }
 250         } catch (TmfAnalysisException e1) {
 251             fail(e1.getMessage());
 252             return;
 253         } finally {
 254             if (module != null) {
 255                 module.dispose();
 256             }
 257         }
 258         assertNotNull(exception);
 259     }
 260
 261     /**
 262      * Test for the
 263      * {@link TmfAnalysisModuleHelperConfigElement#getValidTraceTypes} method
 264      */
 265     @Test
 266     public void testGetValidTraceTypes() {
 267         Set<Class<? extends ITmfTrace>> expected = ImmutableSet.of((Class<? extends ITmfTrace>) TmfTraceStub.class, TmfTraceStub2.class, TmfTraceStub3.class);
 268         Iterable<Class<? extends ITmfTrace>> traceTypes = fReqModule.getValidTraceTypes();
 269         assertEquals(expected, traceTypes);
 270     }
 271
 272     /**
 273      * Test for the
 274      * {@link TmfAnalysisModuleHelperConfigElement#getAnalysisRequirements}
 275      * method
 276      */
 277     @Test
 278     public void testGetRequirements() {
 279         Iterable<TmfAnalysisRequirement> requirements = fReqModule.getAnalysisRequirements();
 280         assertNotNull(requirements);
 281
 282         Map<String, TmfAnalysisRequirement> rMap = new HashMap<>();
 283
 284         for (TmfAnalysisRequirement req : requirements) {
 285             assertFalse(rMap.containsKey(req.getType()));
 286             rMap.put(req.getType(), req);
 287         }
 288         assertEquals(2, rMap.size());
 289
 290         /* Test if all types and values have been obtained */
 291         TmfAnalysisRequirement req = rMap.get(TestRequirementAnalysis.EVENT_TYPE);
 292         assertNotNull(req);
 293
 294         Set<String> values = req.getValues();
 295         assertEquals(3, values.size());
 296         assertTrue(values.contains(TestRequirementAnalysis.EXIT_SYSCALL));
 297         assertTrue(values.contains(TestRequirementAnalysis.SCHED_SWITCH));
 298         assertTrue(values.contains(TestRequirementAnalysis.SCHED_WAKEUP));
 299
 300         req = rMap.get(TestRequirementAnalysis.FIELD_TYPE);
 301         assertNotNull(req);
 302
 303         values = req.getValues();
 304         assertEquals(2, values.size());
 305         assertTrue(values.contains(TestRequirementAnalysis.PID));
 306         assertTrue(values.contains(TestRequirementAnalysis.TID));
 307     }
 308 }