import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
private static final SetMultimap<IKernelAnalysisEventLayout, TmfAnalysisRequirement> LAYOUT_REQ_MAP = NonNullUtils.checkNotNull(HashMultimap.create());
static {
- LAYOUT_REQUIREMENT = new KernelEventLayoutRequirement(ImmutableSet.of((l) -> l.eventSchedSwitch()), ValuePriorityLevel.MANDATORY);
+ LAYOUT_REQUIREMENT = new KernelEventLayoutRequirement(ImmutableSet.of((l) -> l.eventSchedSwitch()), PriorityLevel.MANDATORY);
}
private static IKernelAnalysisEventLayout getLayout(@Nullable ITmfTrace trace) {
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisEventRequirement;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
import com.google.common.collect.ImmutableList.Builder;
}
private final Set<ILayoutToEventName> fEventNames;
- private final ValuePriorityLevel fLevel;
+ private final PriorityLevel fLevel;
/**
* Constructor
* Whether the requirement represented by these mapping is
* mandatory or optional
*/
- public KernelEventLayoutRequirement(Set<ILayoutToEventName> layoutReqs, ValuePriorityLevel level) {
+ public KernelEventLayoutRequirement(Set<ILayoutToEventName> layoutReqs, PriorityLevel level) {
fEventNames = layoutReqs;
fLevel = level;
}
package org.eclipse.tracecompass.lttng2.kernel.core.tests.analysis.kernel;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
import java.util.List;
-import java.util.Set;
import org.eclipse.tracecompass.analysis.os.linux.core.kernel.KernelAnalysisModule;
-import org.eclipse.tracecompass.lttng2.control.core.session.SessionConfigStrings;
import org.eclipse.tracecompass.lttng2.kernel.core.trace.LttngKernelTrace;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestHelper;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.After;
import org.junit.Before;
-import org.junit.Ignore;
import org.junit.Test;
-import com.google.common.collect.ImmutableSet;
-
/**
* Test the {@link KernelAnalysisModule} class
*
trace.dispose();
}
- /**
- * Test for {@link KernelAnalysisModule#getAnalysisRequirements()}
- *
- * FIXME Ignored for now because the analysis does not provide any
- * requirements (it doesn't look for particular event names anymore).
- */
- @Test
- @Ignore
- public void testGetAnalysisRequirements() {
- Iterable<TmfAnalysisRequirement> requirements = fKernelAnalysisModule.getAnalysisRequirements();
- assertNotNull(requirements);
-
- /* There should be the event and domain type */
- TmfAnalysisRequirement eventReq = null;
- TmfAnalysisRequirement domainReq = null;
- int numberOfRequirement = 0;
- for (TmfAnalysisRequirement requirement : requirements) {
- ++numberOfRequirement;
- if (requirement.getType().equals(SessionConfigStrings.CONFIG_ELEMENT_EVENT)) {
- eventReq = requirement;
- } else if (requirement.getType().equals(SessionConfigStrings.CONFIG_ELEMENT_DOMAIN)) {
- domainReq = requirement;
- }
- }
- assertNotNull(eventReq);
- assertNotNull(domainReq);
-
- /* There should be two requirements */
- assertEquals(2, numberOfRequirement);
-
- /* Verify the content of the requirements themselves */
- /* Domain should be kernel */
- assertEquals(1, domainReq.getValues().size());
- for (String domain : domainReq.getValues()) {
- assertEquals(SessionConfigStrings.CONFIG_DOMAIN_TYPE_KERNEL, domain);
- }
-
- /* Events */
- Set<String> expectedEvents = ImmutableSet.of(
-// LttngStrings.EXIT_SYSCALL,
-// LttngStrings.IRQ_HANDLER_ENTRY,
-// LttngStrings.IRQ_HANDLER_EXIT,
-// LttngStrings.SOFTIRQ_ENTRY,
-// LttngStrings.SOFTIRQ_EXIT,
-// LttngStrings.SOFTIRQ_RAISE,
-// LttngStrings.SCHED_SWITCH,
-// LttngStrings.SCHED_PROCESS_FORK,
-// LttngStrings.SCHED_PROCESS_EXIT,
-// LttngStrings.SCHED_PROCESS_FREE,
-// LttngStrings.STATEDUMP_PROCESS_STATE,
-// LttngStrings.SCHED_WAKEUP,
-// LttngStrings.SCHED_WAKEUP_NEW,
-// /* Add the prefix for syscalls */
-// LttngStrings.SYSCALL_PREFIX
- );
-
- assertEquals(0, eventReq.getValues().size());
- for (String event : eventReq.getValues()) {
- assertTrue("Unexpected event " + event, expectedEvents.contains(event));
- }
- }
}
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.tracecompass.internal.lttng2.ust.core.analysis.memory.UstMemoryStateProvider;
-import org.eclipse.tracecompass.lttng2.control.core.session.SessionConfigStrings;
import org.eclipse.tracecompass.lttng2.ust.core.trace.LttngUstTrace;
import org.eclipse.tracecompass.lttng2.ust.core.trace.layout.ILttngUstEventLayout;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisEventRequirement;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
);
/* Initialize the requirements for the analysis: domain and events */
- TmfAnalysisRequirement eventsReq = new TmfAnalysisRequirement(
- nullToEmptyString(SessionConfigStrings.CONFIG_ELEMENT_EVENT), requiredEvents, ValuePriorityLevel.MANDATORY);
+ TmfAnalysisRequirement eventsReq = new TmfAnalysisEventRequirement(requiredEvents, PriorityLevel.MANDATORY);
/*
* In order to have these events, the libc wrapper with probes should be
* loaded
eventsReq.addInformation(nullToEmptyString(Messages.UstMemoryAnalysisModule_EventsLoadingExampleInformation));
/* The domain type of the analysis */
- TmfAnalysisRequirement domainReq = new TmfAnalysisRequirement(nullToEmptyString(SessionConfigStrings.CONFIG_ELEMENT_DOMAIN));
- domainReq.addValue(nullToEmptyString(SessionConfigStrings.CONFIG_DOMAIN_TYPE_UST), ValuePriorityLevel.MANDATORY);
+ // FIXME: The domain requirement should have a way to be verified. It is useless otherwise
+ // TmfAnalysisRequirement domainReq = new TmfAnalysisRequirement(nullToEmptyString(SessionConfigStrings.CONFIG_ELEMENT_DOMAIN));
+ // domainReq.addValue(nullToEmptyString(SessionConfigStrings.CONFIG_DOMAIN_TYPE_UST), ValuePriorityLevel.MANDATORY);
- requirements = ImmutableSet.of(domainReq, eventsReq);
+ requirements = ImmutableSet.of(eventsReq);
fAnalysisRequirements = requirements;
}
return requirements;
import static org.eclipse.tracecompass.common.core.NonNullUtils.nullToEmptyString;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
import java.util.Set;
@NonNullByDefault
public class LttngUstCallStackAnalysisRequirement extends TmfAnalysisRequirement {
- private static String REQUIRMENT_TYPE = "event & context"; //$NON-NLS-1$
-
private List<TmfAnalysisEventFieldRequirement> fEntryRequirements = new ArrayList<>();
private List<TmfAnalysisEventFieldRequirement> fExitRequirements = new ArrayList<>();
/**
* The event layout (non-null)
*/
public LttngUstCallStackAnalysisRequirement(ILttngUstEventLayout layout) {
- super(REQUIRMENT_TYPE);
+ super(Collections.EMPTY_SET, PriorityLevel.MANDATORY);
Set<@NonNull String> requiredEventsFields = ImmutableSet.of(
layout.contextProcname(),
TmfAnalysisEventFieldRequirement requirement = new TmfAnalysisEventFieldRequirement(
layout.eventCygProfileFuncEntry(),
requiredEventsFields,
- ValuePriorityLevel.MANDATORY);
+ PriorityLevel.MANDATORY);
fEntryRequirements.add(requirement);
requirement = new TmfAnalysisEventFieldRequirement(
layout.eventCygProfileFastFuncEntry(),
requiredEventsFields,
- ValuePriorityLevel.MANDATORY);
+ PriorityLevel.MANDATORY);
fEntryRequirements.add(requirement);
requirement = new TmfAnalysisEventFieldRequirement(
layout.eventCygProfileFuncExit(),
requiredEventsFields,
- ValuePriorityLevel.MANDATORY);
+ PriorityLevel.MANDATORY);
fExitRequirements.add(requirement);
requirement = new TmfAnalysisEventFieldRequirement(
layout.eventCygProfileFastFuncExit(),
requiredEventsFields,
- ValuePriorityLevel.MANDATORY);
+ PriorityLevel.MANDATORY);
fExitRequirements.add(requirement);
// Add mandatory values (event names and context names)
- addValue(layout.eventCygProfileFuncEntry(), ValuePriorityLevel.MANDATORY);
- addValue(layout.eventCygProfileFuncExit(), ValuePriorityLevel.MANDATORY);
- addValues(requiredEventsFields, ValuePriorityLevel.MANDATORY);
addInformation(nullToEmptyString(Messages.LttnUstCallStackAnalysisModule_EventsLoadingInformation));
}
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.util.HashMap;
-import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.Platform;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
+import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisRequirementFactory;
import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis;
import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis2;
-import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestRequirementAnalysis;
import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub2;
import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub3;
@Test
public void testGetRequirements() {
Iterable<TmfAnalysisRequirement> requirements = fReqModule.getAnalysisRequirements();
- assertNotNull(requirements);
+ Set<TmfAnalysisRequirement> expected = ImmutableSet.of(
+ AnalysisRequirementFactory.REQUIREMENT_1,
+ AnalysisRequirementFactory.REQUIREMENT_3);
- Map<String, TmfAnalysisRequirement> rMap = new HashMap<>();
-
- for (TmfAnalysisRequirement req : requirements) {
- assertFalse(rMap.containsKey(req.getType()));
- rMap.put(req.getType(), req);
- }
- assertEquals(2, rMap.size());
-
- /* Test if all types and values have been obtained */
- TmfAnalysisRequirement req = rMap.get(TestRequirementAnalysis.EVENT_TYPE);
- assertNotNull(req);
-
- Set<String> values = req.getValues();
- assertEquals(3, values.size());
- assertTrue(values.contains(TestRequirementAnalysis.EXIT_SYSCALL));
- assertTrue(values.contains(TestRequirementAnalysis.SCHED_SWITCH));
- assertTrue(values.contains(TestRequirementAnalysis.SCHED_WAKEUP));
-
- req = rMap.get(TestRequirementAnalysis.FIELD_TYPE);
- assertNotNull(req);
-
- values = req.getValues();
- assertEquals(2, values.size());
- assertTrue(values.contains(TestRequirementAnalysis.PID));
- assertTrue(values.contains(TestRequirementAnalysis.TID));
+ assertEquals(expected, requirements);
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisEventFieldRequirement;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventType;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceWithPreDefinedEvents;
@Test
public void testMandatoryRequirements() {
/* Test mandatory requirement */
- TmfAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), ValuePriorityLevel.MANDATORY);
+ TmfAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.MANDATORY);
assertTrue(req.test(trace));
- req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2), ValuePriorityLevel.MANDATORY);
+ req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2), PriorityLevel.MANDATORY);
assertTrue(req.test(trace));
/* EVENT3 is not part of the trace. Test case that one of the events is part of the trace */
- req = new TmfAnalysisEventFieldRequirement(EVENT3, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2), ValuePriorityLevel.MANDATORY);
+ req = new TmfAnalysisEventFieldRequirement(EVENT3, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2), PriorityLevel.MANDATORY);
assertFalse(req.test(trace));
/* EVENT_FIELD is not an event field of the trace */
- req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2, EVENT_FIELD), ValuePriorityLevel.MANDATORY);
+ req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2, EVENT_FIELD), PriorityLevel.MANDATORY);
assertFalse(req.test(trace));
/* Test case that all events need to have the given fields */
/* A simple trace with no pre-defined events */
TmfTrace traceNoEvents = new TmfTraceStub();
- TmfAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), ValuePriorityLevel.MANDATORY);
+ TmfAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.MANDATORY);
assertTrue(req.test(traceNoEvents));
- req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), ValuePriorityLevel.OPTIONAL);
+ req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.OPTIONAL);
assertTrue(req.test(traceNoEvents));
}
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisEventRequirement;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventType;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceWithPreDefinedEvents;
@Test
public void testMandatoryRequirements() {
/* Test mandatory requirement */
- TmfAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1), ValuePriorityLevel.MANDATORY);
+ TmfAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1), PriorityLevel.MANDATORY);
assertTrue(req.test(fTrace));
- req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2), ValuePriorityLevel.MANDATORY);
+ req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2), PriorityLevel.MANDATORY);
assertTrue(req.test(fTrace));
/* Event 3 is not an event of the trace */
- req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2, EVENT3), ValuePriorityLevel.MANDATORY);
+ req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2, EVENT3), PriorityLevel.MANDATORY);
assertFalse(req.test(fTrace));
- req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT3), ValuePriorityLevel.MANDATORY);
+ req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT3), PriorityLevel.MANDATORY);
assertFalse(req.test(fTrace));
}
/* A simple trace with no pre-defined events */
TmfTrace traceNoEvents = new TmfTraceStub();
- TmfAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT3), ValuePriorityLevel.MANDATORY);
+ TmfAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT3), PriorityLevel.MANDATORY);
assertTrue(req.test(traceNoEvents));
- req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2), ValuePriorityLevel.OPTIONAL);
+ req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2), PriorityLevel.OPTIONAL);
assertTrue(req.test(traceNoEvents));
}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2014 École Polytechnique de Montréal
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Guilliano Molaire - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.tracecompass.tmf.core.tests.analysis.requirements;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.IAnalysisRequirementProvider;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirementHelper;
-import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisModuleTestHelper;
-import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisModuleTestHelper.moduleStubEnum;
-import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisRequirementFactory;
-import org.junit.Test;
-
-import com.google.common.collect.Multimap;
-
-/**
- * Test suite for the {@link TmfAnalysisRequirementHelper} class
- */
-public class AnalysisRequirementHelperTest {
-
- private final @NonNull AnalysisModuleTestHelper fTestModuleHelper = new AnalysisModuleTestHelper(moduleStubEnum.TEST);
- private final @NonNull AnalysisModuleTestHelper fTestModuleHelper2 = new AnalysisModuleTestHelper(moduleStubEnum.TEST2);
-
- /**
- * Test suite for the
- * {@link TmfAnalysisRequirementHelper#getRequirementValues(IAnalysisRequirementProvider, String)}
- * method
- */
- @Test
- public void testGetRequirementValues() {
- /* Test with a supported type */
- String type = AnalysisRequirementFactory.REQUIREMENT_TYPE_1;
- Set<String> values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper, type);
- assertEquals(AnalysisRequirementFactory.REQUIREMENT_VALUES_1.size(), values.size());
-
- /* Test with a type not supported */
- type = AnalysisRequirementFactory.REQUIREMENT_TYPE_2;
- values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper, type);
- assertTrue(values.isEmpty());
- }
-
- /**
- * Test suite for the
- * {@link TmfAnalysisRequirementHelper#getRequirementValues(IAnalysisRequirementProvider, String, ValuePriorityLevel)}
- * method
- */
- @Test
- public void testGetRequirementValuesWithLevel() {
- /* Test with a supported type */
- String type = AnalysisRequirementFactory.REQUIREMENT_TYPE_2;
- Set<String> values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper2, type, ValuePriorityLevel.MANDATORY);
- assertEquals(3, values.size());
-
- /* Test with another value level */
- values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper2, type, ValuePriorityLevel.OPTIONAL);
- assertEquals(2, values.size());
-
- /* Test with a type not supported */
- type = AnalysisRequirementFactory.REQUIREMENT_TYPE_1;
- values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper2, type, ValuePriorityLevel.MANDATORY);
- assertTrue(values.isEmpty());
- }
-
- /**
- * Test suite for the
- * {@link TmfAnalysisRequirementHelper#getRequirementValuesMap(Iterable)}
- * method
- */
- @Test
- public void testGetRequirementValuesMap() {
- Set<@NonNull IAnalysisRequirementProvider> providers = new HashSet<>();
- providers.add(fTestModuleHelper2);
- providers.add(fTestModuleHelper);
-
- Multimap<String, String> valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers);
- assertFalse(valuesByType.isEmpty());
-
- /* There should be 3 types */
- assertEquals(3, valuesByType.keySet().size());
-
- Collection<String> values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_1);
- assertEquals(4, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_2);
- assertEquals(5, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_3);
- assertEquals(3, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
- }
-
- /**
- * Test suite for the
- * {@link TmfAnalysisRequirementHelper#getRequirementValuesMap(Iterable, ValuePriorityLevel)}
- * method
- */
- @Test
- public void testGetRequirementValuesMapWithLevel() {
- Set<@NonNull IAnalysisRequirementProvider> providers = new HashSet<>();
- providers.add(fTestModuleHelper2);
- providers.add(fTestModuleHelper);
-
- /* There should be 3 optional requirements types */
- Multimap<String, String> valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers, ValuePriorityLevel.OPTIONAL);
- assertTrue(!valuesByType.isEmpty());
- assertEquals(1, valuesByType.keySet().size());
-
- Collection<String> values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_1);
- assertTrue(values.isEmpty());
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_2);
- assertEquals(2, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_3);
- assertTrue(values.isEmpty());
-
- /* And 3 types with mandatory requirements */
- valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers, ValuePriorityLevel.MANDATORY);
- assertTrue(!valuesByType.isEmpty());
- assertEquals(3, valuesByType.keySet().size());
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_1);
- assertEquals(4, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_2);
- assertEquals(3, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_3);
- assertEquals(3, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
- }
-
-}
package org.eclipse.tracecompass.tmf.core.tests.analysis.requirements;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.Collections;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
import org.junit.Test;
+import com.google.common.collect.ImmutableSet;
+
/**
* Test suite for the {@link TmfAnalysisRequirement} class.
*
*/
public class AnalysisRequirementTest {
- /* Requirements used in the tests */
- private TmfAnalysisRequirement fRequirement;
- private TmfAnalysisRequirement fSubRequirement;
-
- /* Types of requirement type strings */
- private static final @NonNull String TYPE_A = "Test Type A";
- private static final @NonNull String TYPE_B = "Test Type B";
-
/* Requirement value name strings */
private static final @NonNull String VALUE_A = "Test Value A";
private static final @NonNull String VALUE_B = "Test Value B";
- private static final @NonNull String VALUE_C = "Test Value C";
- private static final @NonNull String VALUE_D = "Test Value D";
- private static final @NonNull String VALUE_E = "Test Value E";
- private static final @NonNull String VALUE_F = "Test Value F";
/* Requirement information strings */
private static final @NonNull String INFO_A = "This is an information.";
private static final @NonNull String INFO_B = "This is another information.";
- private static final @NonNull String INFO_C = "This is the last information.";
/**
- * Test suite for the {@link TmfAnalysisRequirement#addInformation} and the
+ * Test the {@link TmfAnalysisRequirement#addInformation} and the
* {@link TmfAnalysisRequirement#getInformation} methods.
*/
@Test
public void testAddAndGetInformation() {
- fRequirement = new TmfAnalysisRequirement(TYPE_A);
+ TmfAnalysisRequirement requirement = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.OPTIONAL);
- fRequirement.addInformation(INFO_A);
- fRequirement.addInformation(INFO_B);
- fRequirement.addInformation(INFO_B);
+ requirement.addInformation(INFO_A);
+ requirement.addInformation(INFO_B);
+ requirement.addInformation(INFO_B);
- Set<String> information = fRequirement.getInformation();
+ Set<String> information = requirement.getInformation();
assertEquals(2, information.size());
}
/**
- * Test suite for the {@link TmfAnalysisRequirement#addValues} and the
- * {@link TmfAnalysisRequirement#addValue} methods.
- */
- @Test
- public void testAddValuesToRequirement() {
- fRequirement = new TmfAnalysisRequirement(TYPE_A);
-
- assertEquals(0, fRequirement.getValues().size());
-
- List<@NonNull String> values = new ArrayList<>();
- values.add(VALUE_A);
- values.add(VALUE_B);
- values.add(VALUE_C);
- values.add(VALUE_C);
-
- /*
- * Add values to the requirement with the same level, Value C should
- * only exist once
- */
- fRequirement.addValues(values, ValuePriorityLevel.MANDATORY);
- assertEquals(3, fRequirement.getValues().size());
-
- /*
- * The new value should only exist once and its level should be
- * mandatory
- */
- fRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL);
- fRequirement.addValue(VALUE_D, ValuePriorityLevel.MANDATORY);
-
- assertEquals(4, fRequirement.getValues().size());
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_D));
- }
-
- /**
- * Test suite for the {@link TmfAnalysisRequirement#getValueLevel} method.
+ * Test the {@link TmfAnalysisRequirement#getValueLevel} method.
*/
@Test
public void testGetValueLevel() {
- fRequirement = new TmfAnalysisRequirement(TYPE_A);
- fRequirement.addValue(VALUE_A, ValuePriorityLevel.OPTIONAL);
-
- /* Try to get the level of a value */
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_A));
-
- /* Try to get the level of a value that doesn't exist */
- assertNull(fRequirement.getValueLevel(VALUE_B));
- }
+ /* Optional requirement */
+ TmfAnalysisRequirement requirement = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.OPTIONAL);
+ assertEquals(PriorityLevel.OPTIONAL, requirement.getPriorityLevel());
- /**
- * Test suite for the {@link TmfAnalysisRequirement#merge} method with the
- * parameter value MANDATORY.
- */
- @Test
- public void testMergeMandatory() {
- initMergeRequirements(TYPE_A, TYPE_A);
- TmfAnalysisRequirement subReq = fSubRequirement;
- assertNotNull(subReq);
+ /* All or nothing */
+ requirement = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.ALL_OR_NOTHING);
+ assertEquals(PriorityLevel.ALL_OR_NOTHING, requirement.getPriorityLevel());
- assertTrue(fRequirement.merge(subReq, ValuePriorityLevel.MANDATORY));
+ /* At least one */
+ requirement = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.AT_LEAST_ONE);
+ assertEquals(PriorityLevel.AT_LEAST_ONE, requirement.getPriorityLevel());
- assertEquals(fRequirement.getValues().size(), 6);
-
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_A));
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_B));
-
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_C));
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_D));
-
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_E));
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_F));
-
- Set<String> information = fRequirement.getInformation();
-
- assertEquals(3, information.size());
-
- assertTrue(information.contains(INFO_A));
- assertTrue(information.contains(INFO_B));
- assertTrue(information.contains(INFO_C));
+ /* Mandatory */
+ requirement = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.MANDATORY);
+ assertEquals(PriorityLevel.MANDATORY, requirement.getPriorityLevel());
}
/**
- * Test suite for the {@link TmfAnalysisRequirement#merge} method with the
- * parameter value OPTIONAL.
+ * Test the {@link TmfAnalysisRequirement#getValues()} method
*/
@Test
- public void testMergeOptional() {
- initMergeRequirements(TYPE_A, TYPE_A);
- TmfAnalysisRequirement subReq = fSubRequirement;
- assertNotNull(subReq);
-
- assertTrue(fRequirement.merge(subReq, ValuePriorityLevel.OPTIONAL));
-
- assertEquals(6, fRequirement.getValues().size());
-
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_A));
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_B));
-
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_C));
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_D));
-
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_E));
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_F));
-
- Set<String> information = fRequirement.getInformation();
-
- assertEquals(3, information.size());
-
- assertTrue(information.contains(INFO_A));
- assertTrue(information.contains(INFO_B));
- assertTrue(information.contains(INFO_C));
- }
-
- /**
- * Test suite for the {@link TmfAnalysisRequirement#merge} method with
- * different requirement types.
- */
- @Test
- public void testMergeDifferentTypes() {
- initMergeRequirements(TYPE_A, TYPE_B);
- TmfAnalysisRequirement subReq = fSubRequirement;
- assertNotNull(subReq);
-
- assertFalse(fRequirement.merge(subReq, ValuePriorityLevel.OPTIONAL));
- }
-
- /**
- * Test suite for the {@link TmfAnalysisRequirement#isSameType} method.
- */
- @Test
- public void testIsSameRequirementType() {
- fRequirement = new TmfAnalysisRequirement(TYPE_A);
-
- assertTrue(fRequirement.isSameType(new TmfAnalysisRequirement(TYPE_A)));
- assertFalse(fRequirement.isSameType(new TmfAnalysisRequirement(TYPE_B)));
+ public void testGetValues() {
+ ImmutableSet<@NonNull String> values = ImmutableSet.of(VALUE_A, VALUE_B);
+ TmfAnalysisRequirement requirement = new TmfAnalysisRequirement(values, PriorityLevel.OPTIONAL);
+ assertEquals(values, requirement.getValues());
}
- /**
- * Initialize the requirement and sub-requirement for the merge tests.
- *
- * @param typeA
- * The type of the first requirement
- * @param typeB
- * The type of the second requirement
- */
- private void initMergeRequirements(@NonNull String typeA, @NonNull String typeB) {
- fRequirement = new TmfAnalysisRequirement(typeA);
- fRequirement.addValue(VALUE_A, ValuePriorityLevel.MANDATORY);
- fRequirement.addValue(VALUE_B, ValuePriorityLevel.MANDATORY);
-
- fRequirement.addValue(VALUE_C, ValuePriorityLevel.OPTIONAL);
- fRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL);
-
- fRequirement.addInformation(INFO_A);
- fRequirement.addInformation(INFO_B);
-
- /* This sub-requirement will be merged into requirement */
- fSubRequirement = new TmfAnalysisRequirement(typeB);
- fSubRequirement.addValue(VALUE_A, ValuePriorityLevel.MANDATORY);
- fSubRequirement.addValue(VALUE_B, ValuePriorityLevel.OPTIONAL);
-
- fSubRequirement.addValue(VALUE_C, ValuePriorityLevel.MANDATORY);
- fSubRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL);
-
- fSubRequirement.addValue(VALUE_E, ValuePriorityLevel.MANDATORY);
- fSubRequirement.addValue(VALUE_F, ValuePriorityLevel.OPTIONAL);
-
- fSubRequirement.addInformation(INFO_B);
- fSubRequirement.addInformation(INFO_C);
- }
}
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
import com.google.common.collect.ImmutableSet;
private AnalysisRequirementFactory() {}
- public static final String REQUIREMENT_TYPE_1 = "car";
- public static final String REQUIREMENT_TYPE_2 = "factory";
- public static final String REQUIREMENT_TYPE_3 = "code";
-
public static final String REQUIREMENT_VALUE_1 = "value1";
public static final String REQUIREMENT_VALUE_2 = "value2";
public static final String REQUIREMENT_VALUE_3 = "value3";
);
public static final TmfAnalysisRequirement REQUIREMENT_1 =
- new TmfAnalysisRequirement(REQUIREMENT_TYPE_1, REQUIREMENT_VALUES_1, ValuePriorityLevel.MANDATORY);
+ new TmfAnalysisRequirement(REQUIREMENT_VALUES_1, PriorityLevel.MANDATORY);
public static final TmfAnalysisRequirement REQUIREMENT_2 =
- new TmfAnalysisRequirement(REQUIREMENT_TYPE_2);
+ new TmfAnalysisRequirement(REQUIREMENT_VALUES_2, PriorityLevel.MANDATORY);
public static final TmfAnalysisRequirement REQUIREMENT_3 =
- new TmfAnalysisRequirement(REQUIREMENT_TYPE_3, REQUIREMENT_VALUES_3, ValuePriorityLevel.MANDATORY);
+ new TmfAnalysisRequirement(REQUIREMENT_VALUES_3, PriorityLevel.MANDATORY);
- static {
- REQUIREMENT_2.addValue(REQUIREMENT_VALUE_1, ValuePriorityLevel.MANDATORY);
- REQUIREMENT_2.addValue(REQUIREMENT_VALUE_2, ValuePriorityLevel.OPTIONAL);
- REQUIREMENT_2.addValue(REQUIREMENT_VALUE_3, ValuePriorityLevel.MANDATORY);
- REQUIREMENT_2.addValue(REQUIREMENT_VALUE_4, ValuePriorityLevel.OPTIONAL);
- REQUIREMENT_2.addValue(REQUIREMENT_VALUE_5, ValuePriorityLevel.MANDATORY);
- }
}
package org.eclipse.tracecompass.tmf.tests.stubs.analysis;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.Set;
import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.tmf.core.analysis.TmfAbstractAnalysisModule;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
+import com.google.common.collect.ImmutableSet;
+
/**
* Analysis type to test requirements acquisition
*/
@SuppressWarnings({ "javadoc", "nls" })
public class TestRequirementAnalysis extends TmfAbstractAnalysisModule {
/* Test requirement types */
- public static final String EVENT_TYPE = "event";
- public static final String FIELD_TYPE = "field";
+ public static final @NonNull String EVENT_TYPE = "event";
+ public static final @NonNull String FIELD_TYPE = "field";
/* A few event names */
- public static final String EXIT_SYSCALL = "exit_syscall";
- public static final String SCHED_SWITCH = "sched_switch";
- public static final String SCHED_WAKEUP = "sched_wakeup";
+ public static final @NonNull String EXIT_SYSCALL = "exit_syscall";
+ public static final @NonNull String SCHED_SWITCH = "sched_switch";
+ public static final @NonNull String SCHED_WAKEUP = "sched_wakeup";
/* A few fields */
- public static final String PID = "pid";
- public static final String TID = "tid";
+ public static final @NonNull String PID = "pid";
+ public static final @NonNull String TID = "tid";
@Override
public boolean canExecute(ITmfTrace trace) {
@Override
public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
- Map<String, TmfAnalysisRequirement> requirements = new HashMap<>();
-
- /* Event type requirement and values */
- TmfAnalysisRequirement eventReqs = new TmfAnalysisRequirement(EVENT_TYPE);
- eventReqs.addValue(EXIT_SYSCALL, ValuePriorityLevel.MANDATORY);
- eventReqs.addValue(SCHED_SWITCH, ValuePriorityLevel.MANDATORY);
- eventReqs.addValue(SCHED_WAKEUP, ValuePriorityLevel.MANDATORY);
- requirements.put(EVENT_TYPE, eventReqs);
-
- /* Field type requirement and values */
- TmfAnalysisRequirement fieldReqs = new TmfAnalysisRequirement(FIELD_TYPE);
- fieldReqs.addValue(PID, ValuePriorityLevel.MANDATORY);
- fieldReqs.addValue(TID, ValuePriorityLevel.MANDATORY);
- requirements.put(FIELD_TYPE, fieldReqs);
+ Set<TmfAnalysisRequirement> requirements = ImmutableSet.of(
+ AnalysisRequirementFactory.REQUIREMENT_1,
+ AnalysisRequirementFactory.REQUIREMENT_3);
- return requirements.values();
+ return requirements;
}
}
import org.eclipse.tracecompass.internal.tmf.core.Activator;
import org.eclipse.tracecompass.internal.tmf.core.TmfCoreTracer;
import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
import org.eclipse.tracecompass.tmf.core.component.TmfComponent;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.project.model.ITmfPropertiesProvider;
for (TmfAnalysisRequirement requirement : getAnalysisRequirements()) {
if (!requirement.test(trace)) {
builder.append("\n\n"); //$NON-NLS-1$
- builder.append(NLS.bind(Messages.TmfAnalysis_RequirementNotFulfilled, requirement.getType()));
+ builder.append(NLS.bind(Messages.TmfAnalysis_RequirementNotFulfilled, requirement.getPriorityLevel()));
builder.append("\n"); //$NON-NLS-1$
- builder.append(NLS.bind(Messages.TmfAnalysis_RequirementMandatoryValues, requirement.getValues(ValuePriorityLevel.MANDATORY)));
+ builder.append(NLS.bind(Messages.TmfAnalysis_RequirementMandatoryValues, requirement.getValues()));
Set<String> information = requirement.getInformation();
if (!information.isEmpty()) {
builder.append("\n"); //$NON-NLS-1$
TmfAbstractAnalysisModule_NullTrace=Setting a null trace to analysis module
TmfAnalysis_RequirementInformation=Additional information: {0}
TmfAnalysis_RequirementMandatoryValues=Mandatory values: {0}
-TmfAnalysis_RequirementNotFulfilled=Requirement not fulfilled: {0}
+TmfAnalysis_RequirementNotFulfilled={0} Requirement not fulfilled:
TmfAbstractAnalysisModule_RunningAnalysis=Running analysis {0}
TmfAnalysisManager_ErrorParameterProvider=Error instantiating parameter provider
TmfAnalysisModuleHelper_ImpossibleToCreateModule=Could not instantiate module "{0}"
package org.eclipse.tracecompass.tmf.core.analysis.requirements;
import java.util.Collection;
+import java.util.Collections;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
*/
public class TmfAnalysisEventFieldRequirement extends TmfAnalysisRequirement {
- /** The type of requirement */
- private static final String TYPE_EVENT_FIELD = "field"; //$NON-NLS-1$
-
/** The event name of the event containing the mandatory fields */
private String fEventName;
* The list of event field names the trace must have
*/
public TmfAnalysisEventFieldRequirement(String eventName, Collection<String> fields) {
- this(eventName, fields, ValuePriorityLevel.OPTIONAL);
+ this(eventName, fields, PriorityLevel.OPTIONAL);
}
/**
* A level associated with all the values
* @throws IllegalArgumentException if no event names are provided
*/
- public TmfAnalysisEventFieldRequirement(String eventName, Collection<String> fields, ValuePriorityLevel level) {
- super(TYPE_EVENT_FIELD, fields, level);
+ public TmfAnalysisEventFieldRequirement(String eventName, Collection<String> fields, PriorityLevel level) {
+ super(fields, level);
fEventName = eventName;
}
@Override
public boolean test(ITmfTrace trace) {
if ((trace instanceof ITmfTraceWithPreDefinedEvents)) {
- Set<String> mandatoryValues = getValues(ValuePriorityLevel.MANDATORY);
+ // TODO Implement for all levels of requirements
+ Set<String> mandatoryValues = getPriorityLevel().equals(PriorityLevel.MANDATORY) ? getValues() : Collections.EMPTY_SET;
if (mandatoryValues.isEmpty()) {
return true;
}
package org.eclipse.tracecompass.tmf.core.analysis.requirements;
+import java.util.Collection;
+import java.util.Collections;
import java.util.Set;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
* @param eventNames
* The list of event names the trace must have
*/
- public TmfAnalysisEventRequirement(Iterable<String> eventNames) {
- super(TmfAnalysisRequirement.TYPE_EVENT, eventNames, ValuePriorityLevel.OPTIONAL);
+ public TmfAnalysisEventRequirement(Collection<String> eventNames) {
+ super(eventNames, PriorityLevel.OPTIONAL);
}
/**
* @param level
* A level associated with all the values
*/
- public TmfAnalysisEventRequirement(Iterable<String> eventNames, ValuePriorityLevel level) {
- super(TmfAnalysisRequirement.TYPE_EVENT, eventNames, level);
+ public TmfAnalysisEventRequirement(Collection<String> eventNames, PriorityLevel level) {
+ super(eventNames, level);
}
@Override
public boolean test(ITmfTrace trace) {
+ // TODO: implement for all levels
if (trace instanceof ITmfTraceWithPreDefinedEvents) {
Set<String> traceEvents = TmfEventTypeCollectionHelper.getEventNames(((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes());
- Set<String> mandatoryValues = getValues(ValuePriorityLevel.MANDATORY);
+ Set<String> mandatoryValues = getPriorityLevel().equals(PriorityLevel.MANDATORY) ? getValues() : Collections.EMPTY_SET;
return traceEvents.containsAll(mandatoryValues);
}
/*******************************************************************************
- * Copyright (c) 2014 École Polytechnique de Montréal
+ * Copyright (c) 2014, 2016 École Polytechnique de Montréal
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Mathieu Rail - Initial API and implementation
- * Guilliano Molaire - Initial API and implementation
*******************************************************************************/
package org.eclipse.tracecompass.tmf.core.analysis.requirements;
-import java.util.HashMap;
+import java.util.Collection;
import java.util.HashSet;
-import java.util.Map;
-import java.util.Map.Entry;
import java.util.Set;
import java.util.function.Predicate;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
-import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceWithPreDefinedEvents;
-import org.eclipse.tracecompass.tmf.core.trace.TmfEventTypeCollectionHelper;
+
+import com.google.common.collect.ImmutableSet;
/**
- * Class that contains all the values associated with a type needed by an
- * analysis in order to execute. Each value is peered with a level that
- * determines the importance of that specific value for the requirement.
+ * This class represents a requirement that a trace must verify for an analysis
+ * to be able to run on it. This class is the base class for more specific
+ * requirement classes that will implement what to do with the values specified.
*
- * The type gives an indication about the kind of value the requirement
- * contains. The value should depend on the type. For instance, a requirement
- * type could be "event" and all the values that would be added in the
- * requirement object could indicate the possible events handled by the
- * analysis.
- *
- * For these values, a level will be assigned indicating how important the value
- * is based on two possibilities: Mandatory or optional.
+ * A requirement has a priority level which will determine how the values will
+ * be tested on the trace and what the result should be depending on the
+ * presence or absence of those values.
*
* Moreover, useful information that can not be leveled with a priority but are
* important for the proper execution of an analysis can be added.
*
* @author Guilliano Molaire
* @author Mathieu Rail
+ * @author Geneviève Bastien
* @since 2.0
*/
public class TmfAnalysisRequirement implements Predicate<ITmfTrace> {
- /**
- * String for requirement type 'event', that can be used by analysis
- */
- public static final String TYPE_EVENT = "event"; //$NON-NLS-1$
-
- private final String fType;
- private final Map<String, @NonNull ValuePriorityLevel> fValues = new HashMap<>();
+ private final Set<@NonNull String> fValues = new HashSet<>();
private final Set<@NonNull String> fInformation = new HashSet<>();
+ private final PriorityLevel fLevel;
/**
- * The possible level for each value. They must be listed in ascending order
- * of priority.
+ * The possible level for a requirement.
*/
- public enum ValuePriorityLevel {
+ public enum PriorityLevel {
/** The value could be absent and the analysis would still work */
OPTIONAL,
+ /**
+ * The values can be absent, but if one is present, then all should be
+ * present
+ */
+ ALL_OR_NOTHING,
+ /** At least one of the values must be present at runtime */
+ AT_LEAST_ONE,
/** The value must be present at runtime (for the analysis) */
MANDATORY
}
- /**
- * Constructor
- *
- * @param type
- * The type of the requirement
- */
- public TmfAnalysisRequirement(String type) {
- fType = type;
- }
-
/**
* Constructor. Instantiate a requirement object with a list of values of
* the same level
*
- * @param type
- * The type of the requirement
* @param values
* All the values associated with that type
* @param level
* A level associated with all the values
*/
- public TmfAnalysisRequirement(String type, Iterable<String> values, ValuePriorityLevel level) {
- fType = type;
- addValues(values, level);
- }
-
- /**
- * Merges the values of the specified requirement with those of this
- * requirement. All new values will retain their priority value level. If a
- * value was already inside the current requirement, the current priority
- * level will be overridden if the new priority level is higher.
- *
- * @param subRequirement
- * The requirement to be merged into the current one
- * @param maxSubRequirementValueLevel
- * The level associated with all the new values or currently
- * lower priority ones
- * @return True if the merge was successful
- */
- public Boolean merge(TmfAnalysisRequirement subRequirement, ValuePriorityLevel maxSubRequirementValueLevel) {
- /* Two requirements can't be merged if their types are different */
- if (!isSameType(subRequirement)) {
- return false;
- }
-
- Set<String> values = subRequirement.getValues();
- for (String value : values) {
- /*
- * Sub-requirement value levels are limited to
- * maxSubRequirementValueLevel, so the level associated with the
- * values in the merge is the minimum value between
- * maxSubRequirementValueLevel and its true level.
- */
- ValuePriorityLevel valueLevel = subRequirement.getValueLevel(value);
- if (valueLevel == null) {
- throw new NullPointerException();
- }
- int minLevel = Math.min(valueLevel.ordinal(), maxSubRequirementValueLevel.ordinal());
- ValuePriorityLevel subRequirementValueLevel = ValuePriorityLevel.values()[minLevel];
-
- if (fValues.containsKey(value)) {
- /*
- * If a value is already in a requirement, we update the level
- * by the highest value between the current level in the
- * requirement and the level of the value in the
- * sub-requirement.
- */
- ValuePriorityLevel requirementValueLevel = getValueLevel(value);
- if (requirementValueLevel == null) {
- throw new NullPointerException();
- }
-
- int newValueLevel = Math.max(requirementValueLevel.ordinal(), subRequirementValueLevel.ordinal());
- ValuePriorityLevel highestLevel = ValuePriorityLevel.values()[newValueLevel];
- addValue(value, highestLevel);
- }
- else {
- addValue(value, subRequirementValueLevel);
- }
- }
-
- /* Merge the information */
- fInformation.addAll(subRequirement.getInformation());
-
- return true;
- }
-
- /**
- * Adds a list of value inside the requirement with the same level.
- *
- * @param values
- * A list of value
- * @param level
- * The level associated with all the values
- */
- public void addValues(Iterable<String> values, ValuePriorityLevel level) {
- for (String value : values) {
- addValue(value, level);
- }
- }
-
- /**
- * Adds a value with his associated level into the requirement. If the value
- * is already contained in the requirement the method modifies its existing
- * value level.
- *
- * @param value
- * The value
- * @param level
- * The level
- */
- public void addValue(String value, ValuePriorityLevel level) {
- synchronized (fValues) {
- fValues.put(value, level);
- }
+ public TmfAnalysisRequirement(Collection<String> values, PriorityLevel level) {
+ fLevel = level;
+ fValues.addAll(values);
}
/**
fInformation.add(information);
}
- /**
- * Determines if the analysis requirement has the same type of another
- * requirement.
- *
- * @param requirement
- * Requirement whose type is to be compared to this requirement's
- * type.
- * @return True if the two requirements have the same type; otherwise false
- */
- public Boolean isSameType(TmfAnalysisRequirement requirement) {
- return fType.equals(requirement.getType());
- }
-
- /**
- * Gets the requirement type. The type is read only.
- *
- * @return The type of this requirement
- */
- public String getType() {
- return fType;
- }
-
/**
* Gets all the values associated with the requirement.
*
*/
public Set<String> getValues() {
synchronized (fValues) {
- return fValues.keySet();
- }
- }
-
- /**
- * Gets all the values associated with the requirement with a given priority
- * level.
- *
- * @param level
- * The desired level
- * @return Set containing the values with the given priority level
- */
- public Set<String> getValues(ValuePriorityLevel level) {
- synchronized (fValues) {
- Set<String> values = new HashSet<>();
- for (Entry<String, ValuePriorityLevel> entry : fValues.entrySet()) {
- if (entry.getValue() == level) {
- values.add(entry.getKey());
- }
- }
- return values;
+ return ImmutableSet.copyOf(fValues);
}
}
}
/**
- * Gets the level associated with a particular type
+ * Gets the level of this requirement
*
- * @param value
- * The value
- * @return The level or null if the value does not exist
+ * @return The level of the requirement
*/
- public @Nullable ValuePriorityLevel getValueLevel(String value) {
- synchronized (fValues) {
- return fValues.get(value);
- }
+ public PriorityLevel getPriorityLevel() {
+ return fLevel;
}
/**
*/
@Override
public boolean test(ITmfTrace trace) {
- switch (fType) {
- case TYPE_EVENT:
- if (trace instanceof ITmfTraceWithPreDefinedEvents) {
- Set<String> traceEvents = TmfEventTypeCollectionHelper.getEventNames(((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes());
- Set<String> mandatoryValues = getValues(ValuePriorityLevel.MANDATORY);
- return traceEvents.containsAll(mandatoryValues);
- }
- break;
- default:
- return true;
- }
return true;
}
@Override
public String toString() {
- return fType + ": " + fValues; //$NON-NLS-1$
+ return getClass().getName() + ": " + fValues; //$NON-NLS-1$
}
}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2014 École Polytechnique de Montréal
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Guilliano Molaire - Initial API and implementation
- * Mathieu Rail - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.tracecompass.tmf.core.analysis.requirements;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
-
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.SetMultimap;
-
-/**
- * Helper class to simplify analysis requirement management.
- *
- * @author Guilliano Molaire
- * @since 2.0
- */
-public final class TmfAnalysisRequirementHelper {
-
- /**
- * Private constructor. The class should not be instantiated.
- */
- private TmfAnalysisRequirementHelper() {
- }
-
- /**
- * Gets the requirement values of a given type from an analysis requirement
- * provider. Only values linked to the type will be returned.
- *
- * @param provider
- * The analysis requirement provider
- * @param type
- * The type of the requirement values we need
- * @return The list of values for the specified type
- */
- public static Set<String> getRequirementValues(IAnalysisRequirementProvider provider, String type) {
- Set<String> values = new HashSet<>();
- for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
- if (requirement.getType().equalsIgnoreCase(type)) {
- values.addAll(requirement.getValues());
- }
- }
- return values;
- }
-
- /**
- * Gets the requirement values of a given type from an analysis requirement
- * provider, with the specified level. Only values associated with that type
- * and level will be returned.
- *
- * @param provider
- * The analysis requirement provider
- * @param type
- * The type of the requirement values we need
- * @param level
- * The priority level of the values to be returned
- * @return The list of values for the specified type
- */
- public static Set<String> getRequirementValues(IAnalysisRequirementProvider provider, String type, ValuePriorityLevel level) {
- Set<String> values = new HashSet<>();
- for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
- if (requirement.getType().equalsIgnoreCase(type)) {
- for (String value : requirement.getValues()) {
- if (requirement.getValueLevel(value) == level) {
- values.add(value);
- }
- }
- }
- }
- return values;
- }
-
- /**
- * Gets a map in which the keys are the types of different requirements and
- * the values represent a set of requirement values linked to that type.
- *
- * @param providers
- * The set of analysis requirement provider
- * @return A map with the values keyed by type
- */
- public static SetMultimap<String, String> getRequirementValuesMap(Iterable<IAnalysisRequirementProvider> providers) {
- SetMultimap<String, String> valuesByType = HashMultimap.create();
- for (IAnalysisRequirementProvider provider : providers) {
- for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
- valuesByType.putAll(requirement.getType(), requirement.getValues());
- }
- }
- return valuesByType;
- }
-
- /**
- * Gets a map in which the keys are the types of different requirements and
- * the values represents a list of requirement values linked to that type.
- * We only take values with the same priority level as the argument.
- *
- * @param providers
- * The set of analysis requirement provider
- * @param level
- * The priority level of the values to be returned
- * @return A map with the values keyed by type
- */
- public static SetMultimap<String, String> getRequirementValuesMap(Iterable<IAnalysisRequirementProvider> providers, ValuePriorityLevel level) {
- SetMultimap<String, String> valuesByType = HashMultimap.create();
- for (IAnalysisRequirementProvider provider : providers) {
- for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
- /* Since it's a set, there will be no duplicate */
- for (String value : requirement.getValues()) {
- if (requirement.getValueLevel(value) == level) {
- valuesByType.put(requirement.getType(), value);
- }
- }
- }
- }
- return valuesByType;
- }
-}
projects / deliverable / tracecompass.git / commitdiff
