tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/trace/TmfTraceUtilsTest.java - tracecompass/org.eclipse.tracecompass - Git at Google

 /*******************************************************************************
  * Copyright (c) 2014, 2017 Ericsson
  *
  * All rights reserved. This program and the accompanying materials are
  * made available under the terms of the Eclipse Public License 2.0 which
  * accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *   Alexandre Montplaisir - Initial API and implementation
  *******************************************************************************/

 package org.eclipse.tracecompass.tmf.core.tests.trace;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

 import java.util.Collection;

 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.tracecompass.analysis.counters.core.aspects.CounterAspect;
 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
 import org.eclipse.tracecompass.tmf.core.event.aspect.ITmfEventAspect;
 import org.eclipse.tracecompass.tmf.core.event.aspect.TmfCpuAspect;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
 import org.eclipse.tracecompass.tmf.core.tests.analysis.AnalysisManagerTest;
 import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestTrace;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
 import org.eclipse.tracecompass.tmf.core.trace.TmfTrace;
 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
 import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis;
 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;

 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;

 /**
  * Test suite for {@link TmfTraceUtils}
  */
 public class TmfTraceUtilsTest {

     private static final @NonNull TestEventAspect TEST_ASPECT = new TestEventAspect();

     private static final TmfTestTrace TEST_TRACE = TmfTestTrace.A_TEST_10K;

     private TmfTrace fTrace;

     // ------------------------------------------------------------------------
     // Test trace class definition
     // ------------------------------------------------------------------------
     private static final @NonNull Collection<ITmfEventAspect<?>> EVENT_ASPECTS;
     static {
         ImmutableList.Builder<ITmfEventAspect<?>> builder = ImmutableList.builder();
         builder.add(new TmfCpuAspect() {
             @Override
             public Integer resolve(ITmfEvent event) {
                 return 1;
             }
         });
         builder.addAll(TmfTrace.BASE_ASPECTS);
         EVENT_ASPECTS = builder.build();
     }

     private static class TmfTraceStubWithAspects extends TmfTraceStub {

         public TmfTraceStubWithAspects(String path) throws TmfTraceException {
             super(path, ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
         }

         @Override
         public Iterable<ITmfEventAspect<?>> getEventAspects() {
             return EVENT_ASPECTS;
         }

     }

     private static class TestEventAspect implements ITmfEventAspect<@NonNull Integer> {

         public static final Integer RESOLVED_VALUE = 2;
         public static final @NonNull String ASPECT_NAME = "test";

         @Override
         public @NonNull String getName() {
             return ASPECT_NAME;
         }

         @Override
         public @NonNull String getHelpText() {
             return ASPECT_NAME;
         }

         @Override
         public @Nullable Integer resolve(@NonNull ITmfEvent event) {
             return RESOLVED_VALUE;
         }

     }

     // ------------------------------------------------------------------------
     // Housekeeping
     // ------------------------------------------------------------------------

     /**
      * Test setup
      */
     @Before
     public void setUp() {
         try {
             fTrace = new TmfTraceStubWithAspects(TEST_TRACE.getFullPath());
             TmfSignalManager.deregister(fTrace);
             fTrace.indexTrace(true);
         } catch (final TmfTraceException e) {
             fail(e.getMessage());
         }
     }

     /**
      * Test cleanup
      */
     @After
     public void tearDown() {
         fTrace.dispose();
         fTrace = null;
     }

     // ------------------------------------------------------------------------
     // Test methods
     // ------------------------------------------------------------------------

     /**
      * Test the {@link TmfTraceUtils#getAnalysisModuleOfClass} method.
      */
     @Test
     public void testGetModulesByClass() {
         TmfTrace trace = fTrace;
         assertNotNull(trace);

         /* Open the trace, the modules should be populated */
         trace.traceOpened(new TmfTraceOpenedSignal(this, trace, null));

         Iterable<TestAnalysis> testModules = TmfTraceUtils.getAnalysisModulesOfClass(trace, TestAnalysis.class);
         assertTrue(testModules.iterator().hasNext());
         /*
          * FIXME: The exact count depends on the context the test is run (full test
          * suite or this file only), but there must be at least 2 modules
          */
         assertTrue(Iterables.size(testModules) >= 2);

         TestAnalysis module = TmfTraceUtils.getAnalysisModuleOfClass(trace, TestAnalysis.class, AnalysisManagerTest.MODULE_PARAM);
         assertNotNull(module);
         IAnalysisModule traceModule = trace.getAnalysisModule(AnalysisManagerTest.MODULE_PARAM);
         assertNotNull(traceModule);
         assertEquals(module, traceModule);

     }

     /**
      * Test the {@link TmfTraceUtils#getAnalysisModuleOfClass} method.
      */
     @Test
     public void testGetModulesByClassForHost() {
         TmfTrace trace = fTrace;
         assertNotNull(trace);

         /*
          * Open the trace, the modules should be populated and make sure the signal is
          * received by the trace manager
          */
         TmfTraceOpenedSignal signal = new TmfTraceOpenedSignal(this, trace, null);
         trace.traceOpened(signal);
         TmfTraceManager.getInstance().traceOpened(signal);

         Iterable<TestAnalysis> testModules = TmfTraceUtils.getAnalysisModulesOfClass(trace.getHostId(), TestAnalysis.class);
         assertTrue(testModules.iterator().hasNext());
         /*
          * FIXME: The exact count depends on the context the test is run (full test
          * suite or this file only), but there must be at least 2 modules
          */
         assertTrue(Iterables.size(testModules) >= 2);
     }

     /**
      * Test the
      * {@link TmfTraceUtils#resolveEventAspectOfClassForEvent(ITmfTrace, Class, ITmfEvent)}
      * method.
      */
     @Test
     public void testResolveEventAspectsOfClassForEvent() {
         TmfTrace trace = fTrace;
         assertNotNull(trace);

         ITmfContext context = trace.seekEvent(0L);
         ITmfEvent event = trace.getNext(context);
         assertNotNull(event);

         /* Make sure the CPU aspect returns the expected value */
         Object cpuObj = TmfTraceUtils.resolveEventAspectOfClassForEvent(trace, TmfCpuAspect.class, event);
         assertNotNull(cpuObj);
         assertEquals(1, cpuObj);

     }

     /**
      * Test the
      * {@link TmfTraceUtils#resolveAspectOfNameForEvent(ITmfTrace, String, ITmfEvent)}
      * method.
      */
     @Test
     public void testResolveEventAspectsOfNameForEvent() {
         TmfTrace trace = fTrace;
         assertNotNull(trace);

         ITmfContext context = trace.seekEvent(0L);
         ITmfEvent event = trace.getNext(context);
         assertNotNull(event);

         /* Make sure the CPU aspect returns the expected value */
         Object cpuObj = TmfTraceUtils.resolveAspectOfNameForEvent(trace, "cpu", event);
         assertNotNull(cpuObj);
         assertEquals(1, cpuObj);

     }

     /**
      * Test the {@link TmfTraceUtils#getEventAspects(ITmfTrace, Class)} method
      */
     @Test
     public void testGetAspects() {
         TmfTrace trace = fTrace;

         assertNotNull(trace);

         Iterable<@NonNull ITmfEventAspect<?>> aspect = TmfTraceUtils.getEventAspects(trace, TestEventAspect.class);
         assertNotNull(aspect);
         assertEquals(1, Iterables.size(aspect));
         assertTrue(Iterables.contains(aspect, TEST_ASPECT));

         Iterable<@NonNull ITmfEventAspect<?>> cpuAspect = TmfTraceUtils.getEventAspects(trace, TmfCpuAspect.class);
         assertNotNull(cpuAspect);
         assertEquals("CPU", cpuAspect.iterator().next().getName());

         Iterable<@NonNull ITmfEventAspect<?>> badAspect = TmfTraceUtils.getEventAspects(trace, CounterAspect.class);
         assertNotNull(badAspect);
         assertTrue(Iterables.isEmpty(badAspect));
     }

     /**
      * Test the {@link TmfTraceUtils#registerEventAspect(ITmfEventAspect)} method
      */
     @Test
     public void testAdditionalAspects() {
         TmfTrace trace = fTrace;

         assertNotNull(trace);

         ITmfContext context = trace.seekEvent(0L);
         ITmfEvent event = trace.getNext(context);
         assertNotNull(event);

         // Make sure the aspect is not resolved
         Object obj = TmfTraceUtils.resolveEventAspectOfClassForEvent(trace, TestEventAspect.class, event);
         assertNull(obj);

         obj = TmfTraceUtils.resolveAspectOfNameForEvent(trace, TestEventAspect.ASPECT_NAME, event);
         assertNull(obj);

         Integer val = TmfTraceUtils.resolveIntEventAspectOfClassForEvent(trace, TestEventAspect.class, event);
         assertNull(val);

         // Register the aspect
         TmfTraceUtils.registerEventAspect(TEST_ASPECT);
         // See that the aspect is resolved now
         obj = TmfTraceUtils.resolveEventAspectOfClassForEvent(trace, TestEventAspect.class, event);
         assertNotNull(obj);
         assertEquals(TestEventAspect.RESOLVED_VALUE, obj);

         // See if it is resolved by name as well
         obj = TmfTraceUtils.resolveAspectOfNameForEvent(trace, TestEventAspect.ASPECT_NAME, event);
         assertNotNull(obj);
         assertEquals(TestEventAspect.RESOLVED_VALUE, obj);

         // See if it is resolved by Integer type as well
         val = TmfTraceUtils.resolveIntEventAspectOfClassForEvent(trace, TestEventAspect.class, event);
         assertNotNull(val);
         assertEquals(TestEventAspect.RESOLVED_VALUE, val);
     }
 }
	/*******************************************************************************
	* Copyright (c) 2014, 2017 Ericsson
	*
	* All rights reserved. This program and the accompanying materials are
	* made available under the terms of the Eclipse Public License 2.0 which
	* accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Alexandre Montplaisir - Initial API and implementation
	*******************************************************************************/

	package org.eclipse.tracecompass.tmf.core.tests.trace;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertNull;
	import static org.junit.Assert.assertTrue;
	import static org.junit.Assert.fail;

	import java.util.Collection;

	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.jdt.annotation.Nullable;
	import org.eclipse.tracecompass.analysis.counters.core.aspects.CounterAspect;
	import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
	import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
	import org.eclipse.tracecompass.tmf.core.event.aspect.ITmfEventAspect;
	import org.eclipse.tracecompass.tmf.core.event.aspect.TmfCpuAspect;
	import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
	import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
	import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
	import org.eclipse.tracecompass.tmf.core.tests.analysis.AnalysisManagerTest;
	import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestTrace;
	import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
	import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
	import org.eclipse.tracecompass.tmf.core.trace.TmfTrace;
	import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
	import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
	import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis;
	import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
	import org.junit.After;
	import org.junit.Before;
	import org.junit.Test;

	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.Iterables;

	/**
	* Test suite for {@link TmfTraceUtils}
	*/
	public class TmfTraceUtilsTest {

	private static final @NonNull TestEventAspect TEST_ASPECT = new TestEventAspect();

	private static final TmfTestTrace TEST_TRACE = TmfTestTrace.A_TEST_10K;

	private TmfTrace fTrace;

	// ------------------------------------------------------------------------
	// Test trace class definition
	// ------------------------------------------------------------------------
	private static final @NonNull Collection<ITmfEventAspect<?>> EVENT_ASPECTS;
	static {
	ImmutableList.Builder<ITmfEventAspect<?>> builder = ImmutableList.builder();
	builder.add(new TmfCpuAspect() {
	@Override
	public Integer resolve(ITmfEvent event) {
	return 1;
	}
	});
	builder.addAll(TmfTrace.BASE_ASPECTS);
	EVENT_ASPECTS = builder.build();
	}

	private static class TmfTraceStubWithAspects extends TmfTraceStub {

	public TmfTraceStubWithAspects(String path) throws TmfTraceException {
	super(path, ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
	}

	@Override
	public Iterable<ITmfEventAspect<?>> getEventAspects() {
	return EVENT_ASPECTS;
	}

	}

	private static class TestEventAspect implements ITmfEventAspect<@NonNull Integer> {

	public static final Integer RESOLVED_VALUE = 2;
	public static final @NonNull String ASPECT_NAME = "test";

	@Override
	public @NonNull String getName() {
	return ASPECT_NAME;
	}

	@Override
	public @NonNull String getHelpText() {
	return ASPECT_NAME;
	}

	@Override
	public @Nullable Integer resolve(@NonNull ITmfEvent event) {
	return RESOLVED_VALUE;
	}

	}

	// ------------------------------------------------------------------------
	// Housekeeping
	// ------------------------------------------------------------------------

	/**
	* Test setup
	*/
	@Before
	public void setUp() {
	try {
	fTrace = new TmfTraceStubWithAspects(TEST_TRACE.getFullPath());
	TmfSignalManager.deregister(fTrace);
	fTrace.indexTrace(true);
	} catch (final TmfTraceException e) {
	fail(e.getMessage());
	}
	}

	/**
	* Test cleanup
	*/
	@After
	public void tearDown() {
	fTrace.dispose();
	fTrace = null;
	}

	// ------------------------------------------------------------------------
	// Test methods
	// ------------------------------------------------------------------------

	/**
	* Test the {@link TmfTraceUtils#getAnalysisModuleOfClass} method.
	*/
	@Test
	public void testGetModulesByClass() {
	TmfTrace trace = fTrace;
	assertNotNull(trace);

	/* Open the trace, the modules should be populated */
	trace.traceOpened(new TmfTraceOpenedSignal(this, trace, null));

	Iterable<TestAnalysis> testModules = TmfTraceUtils.getAnalysisModulesOfClass(trace, TestAnalysis.class);
	assertTrue(testModules.iterator().hasNext());
	/*
	* FIXME: The exact count depends on the context the test is run (full test
	* suite or this file only), but there must be at least 2 modules
	*/
	assertTrue(Iterables.size(testModules) >= 2);

	TestAnalysis module = TmfTraceUtils.getAnalysisModuleOfClass(trace, TestAnalysis.class, AnalysisManagerTest.MODULE_PARAM);
	assertNotNull(module);
	IAnalysisModule traceModule = trace.getAnalysisModule(AnalysisManagerTest.MODULE_PARAM);
	assertNotNull(traceModule);
	assertEquals(module, traceModule);

	}

	/**
	* Test the {@link TmfTraceUtils#getAnalysisModuleOfClass} method.
	*/
	@Test
	public void testGetModulesByClassForHost() {
	TmfTrace trace = fTrace;
	assertNotNull(trace);

	/*
	* Open the trace, the modules should be populated and make sure the signal is
	* received by the trace manager
	*/
	TmfTraceOpenedSignal signal = new TmfTraceOpenedSignal(this, trace, null);
	trace.traceOpened(signal);
	TmfTraceManager.getInstance().traceOpened(signal);

	Iterable<TestAnalysis> testModules = TmfTraceUtils.getAnalysisModulesOfClass(trace.getHostId(), TestAnalysis.class);
	assertTrue(testModules.iterator().hasNext());
	/*
	* FIXME: The exact count depends on the context the test is run (full test
	* suite or this file only), but there must be at least 2 modules
	*/
	assertTrue(Iterables.size(testModules) >= 2);
	}

	/**
	* Test the
	* {@link TmfTraceUtils#resolveEventAspectOfClassForEvent(ITmfTrace, Class, ITmfEvent)}
	* method.
	*/
	@Test
	public void testResolveEventAspectsOfClassForEvent() {
	TmfTrace trace = fTrace;
	assertNotNull(trace);

	ITmfContext context = trace.seekEvent(0L);
	ITmfEvent event = trace.getNext(context);
	assertNotNull(event);

	/* Make sure the CPU aspect returns the expected value */
	Object cpuObj = TmfTraceUtils.resolveEventAspectOfClassForEvent(trace, TmfCpuAspect.class, event);
	assertNotNull(cpuObj);
	assertEquals(1, cpuObj);

	}

	/**
	* Test the
	* {@link TmfTraceUtils#resolveAspectOfNameForEvent(ITmfTrace, String, ITmfEvent)}
	* method.
	*/
	@Test
	public void testResolveEventAspectsOfNameForEvent() {
	TmfTrace trace = fTrace;
	assertNotNull(trace);

	ITmfContext context = trace.seekEvent(0L);
	ITmfEvent event = trace.getNext(context);
	assertNotNull(event);

	/* Make sure the CPU aspect returns the expected value */
	Object cpuObj = TmfTraceUtils.resolveAspectOfNameForEvent(trace, "cpu", event);
	assertNotNull(cpuObj);
	assertEquals(1, cpuObj);

	}

	/**
	* Test the {@link TmfTraceUtils#getEventAspects(ITmfTrace, Class)} method
	*/
	@Test
	public void testGetAspects() {
	TmfTrace trace = fTrace;

	assertNotNull(trace);

	Iterable<@NonNull ITmfEventAspect<?>> aspect = TmfTraceUtils.getEventAspects(trace, TestEventAspect.class);
	assertNotNull(aspect);
	assertEquals(1, Iterables.size(aspect));
	assertTrue(Iterables.contains(aspect, TEST_ASPECT));

	Iterable<@NonNull ITmfEventAspect<?>> cpuAspect = TmfTraceUtils.getEventAspects(trace, TmfCpuAspect.class);
	assertNotNull(cpuAspect);
	assertEquals("CPU", cpuAspect.iterator().next().getName());

	Iterable<@NonNull ITmfEventAspect<?>> badAspect = TmfTraceUtils.getEventAspects(trace, CounterAspect.class);
	assertNotNull(badAspect);
	assertTrue(Iterables.isEmpty(badAspect));
	}

	/**
	* Test the {@link TmfTraceUtils#registerEventAspect(ITmfEventAspect)} method
	*/
	@Test
	public void testAdditionalAspects() {
	TmfTrace trace = fTrace;

	assertNotNull(trace);

	ITmfContext context = trace.seekEvent(0L);
	ITmfEvent event = trace.getNext(context);
	assertNotNull(event);

	// Make sure the aspect is not resolved
	Object obj = TmfTraceUtils.resolveEventAspectOfClassForEvent(trace, TestEventAspect.class, event);
	assertNull(obj);

	obj = TmfTraceUtils.resolveAspectOfNameForEvent(trace, TestEventAspect.ASPECT_NAME, event);
	assertNull(obj);

	Integer val = TmfTraceUtils.resolveIntEventAspectOfClassForEvent(trace, TestEventAspect.class, event);
	assertNull(val);

	// Register the aspect
	TmfTraceUtils.registerEventAspect(TEST_ASPECT);
	// See that the aspect is resolved now
	obj = TmfTraceUtils.resolveEventAspectOfClassForEvent(trace, TestEventAspect.class, event);
	assertNotNull(obj);
	assertEquals(TestEventAspect.RESOLVED_VALUE, obj);

	// See if it is resolved by name as well
	obj = TmfTraceUtils.resolveAspectOfNameForEvent(trace, TestEventAspect.ASPECT_NAME, event);
	assertNotNull(obj);
	assertEquals(TestEventAspect.RESOLVED_VALUE, obj);

	// See if it is resolved by Integer type as well
	val = TmfTraceUtils.resolveIntEventAspectOfClassForEvent(trace, TestEventAspect.class, event);
	assertNotNull(val);
	assertEquals(TestEventAspect.RESOLVED_VALUE, val);
	}
	}