From: Geneviève Bastien Date: Thu, 28 Apr 2016 14:27:25 +0000 (-0400) Subject: requirements: Clean up the API of TmfAnalysisRequirement X-Git-Url: http://git.efficios.com/?a=commitdiff_plain;h=66ee355dc302a5f0d26dc43a2570881d1e3f7401;p=deliverable%2Ftracecompass.git requirements: Clean up the API of TmfAnalysisRequirement * Remove the 'fType' field in favor of sub-classing * Remove the possibility to merge requirements, a composite requirement will be added in a later patch * Have the priority level be for the whole requirement instead of per-values * Values cannot be added except at the constructor * Remove requirement helper class and tests: the methods there referred to the type which does not exist anymore. Change-Id: I01897cd705452833cbdbe6c57dd819a5a1ecfd22 Signed-off-by: Geneviève Bastien --- diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java index b67a110d12..195e63114c 100644 --- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java +++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java @@ -39,7 +39,7 @@ import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; 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; @@ -72,7 +72,7 @@ public class KernelCpuUsageAnalysis extends TmfStateSystemAnalysisModule { private static final SetMultimap 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) { diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java index 6e0ec58727..f17c32be0f 100644 --- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java +++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java @@ -14,7 +14,7 @@ import java.util.Set; 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; @@ -45,7 +45,7 @@ public class KernelEventLayoutRequirement { } private final Set fEventNames; - private final ValuePriorityLevel fLevel; + private final PriorityLevel fLevel; /** * Constructor @@ -56,7 +56,7 @@ public class KernelEventLayoutRequirement { * Whether the requirement represented by these mapping is * mandatory or optional */ - public KernelEventLayoutRequirement(Set layoutReqs, ValuePriorityLevel level) { + public KernelEventLayoutRequirement(Set layoutReqs, PriorityLevel level) { fEventNames = layoutReqs; fLevel = level; } diff --git a/lttng/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/LttngKernelAnalysisTest.java b/lttng/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/LttngKernelAnalysisTest.java index 0e3fd96e28..6ed0d35835 100644 --- a/lttng/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/LttngKernelAnalysisTest.java +++ b/lttng/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/LttngKernelAnalysisTest.java @@ -12,7 +12,6 @@ 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; @@ -20,14 +19,11 @@ import static org.junit.Assert.assertTrue; 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; @@ -37,11 +33,8 @@ import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils; 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 * @@ -126,65 +119,4 @@ public class LttngKernelAnalysisTest { 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 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 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)); - } - } } diff --git a/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java b/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java index d20ac4d03d..bb4b26b546 100644 --- a/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java +++ b/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java @@ -21,11 +21,11 @@ import java.util.Set; 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; @@ -92,8 +92,7 @@ public class UstMemoryAnalysisModule extends 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 @@ -102,10 +101,11 @@ public class UstMemoryAnalysisModule extends TmfStateSystemAnalysisModule { 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; diff --git a/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/internal/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysisRequirement.java b/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/internal/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysisRequirement.java index 4864aee33c..150eadecc8 100644 --- a/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/internal/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysisRequirement.java +++ b/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/internal/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysisRequirement.java @@ -11,6 +11,7 @@ package org.eclipse.tracecompass.internal.lttng2.ust.ui.analysis.callstack; 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; @@ -32,8 +33,6 @@ import com.google.common.collect.ImmutableSet; @NonNullByDefault public class LttngUstCallStackAnalysisRequirement extends TmfAnalysisRequirement { - private static String REQUIRMENT_TYPE = "event & context"; //$NON-NLS-1$ - private List fEntryRequirements = new ArrayList<>(); private List fExitRequirements = new ArrayList<>(); /** @@ -43,7 +42,7 @@ public class LttngUstCallStackAnalysisRequirement extends TmfAnalysisRequirement * 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(), @@ -51,31 +50,28 @@ public class LttngUstCallStackAnalysisRequirement extends TmfAnalysisRequirement 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)); } diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleHelperTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleHelperTest.java index 665aa2aa4d..9957260fd2 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleHelperTest.java +++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleHelperTest.java @@ -20,8 +20,6 @@ import static org.junit.Assert.assertNull; 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; @@ -36,9 +34,9 @@ import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestTrace; 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; @@ -357,32 +355,10 @@ public class AnalysisModuleHelperTest { @Test public void testGetRequirements() { Iterable requirements = fReqModule.getAnalysisRequirements(); - assertNotNull(requirements); + Set expected = ImmutableSet.of( + AnalysisRequirementFactory.REQUIREMENT_1, + AnalysisRequirementFactory.REQUIREMENT_3); - Map 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 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); } } diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventFieldRequirementTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventFieldRequirementTest.java index f03e42c7b9..3b306f6f79 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventFieldRequirementTest.java +++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventFieldRequirementTest.java @@ -20,7 +20,7 @@ import java.util.Set; 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; @@ -137,18 +137,18 @@ public class AnalysisEventFieldRequirementTest { @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 */ @@ -169,10 +169,10 @@ public class AnalysisEventFieldRequirementTest { /* 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)); } diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventRequirementTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventRequirementTest.java index 459c6ebb04..942730ceef 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventRequirementTest.java +++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventRequirementTest.java @@ -18,7 +18,7 @@ import java.util.Set; 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; @@ -108,17 +108,17 @@ public class AnalysisEventRequirementTest { @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)); } @@ -131,10 +131,10 @@ public class AnalysisEventRequirementTest { /* 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)); } diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementHelperTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementHelperTest.java deleted file mode 100644 index cec6c26594..0000000000 --- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementHelperTest.java +++ /dev/null @@ -1,173 +0,0 @@ -/******************************************************************************* - * 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 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 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 valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers); - assertFalse(valuesByType.isEmpty()); - - /* There should be 3 types */ - assertEquals(3, valuesByType.keySet().size()); - - Collection 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 valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers, ValuePriorityLevel.OPTIONAL); - assertTrue(!valuesByType.isEmpty()); - assertEquals(1, valuesByType.keySet().size()); - - Collection 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)); - } - -} diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementTest.java index fcf708aea4..cba7c9defa 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementTest.java +++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementTest.java @@ -14,20 +14,18 @@ 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. * @@ -36,40 +34,27 @@ import org.junit.Test; */ 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 information = fRequirement.getInformation(); + Set information = requirement.getInformation(); assertEquals(2, information.size()); @@ -78,173 +63,35 @@ public class AnalysisRequirementTest { } /** - * 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 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 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); - } } diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisRequirementFactory.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisRequirementFactory.java index e500487da6..a778f0e038 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisRequirementFactory.java +++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisRequirementFactory.java @@ -16,7 +16,7 @@ import java.util.Set; 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; @@ -29,10 +29,6 @@ public final class AnalysisRequirementFactory { 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"; @@ -58,17 +54,10 @@ public final class AnalysisRequirementFactory { ); 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); - } } diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestRequirementAnalysis.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestRequirementAnalysis.java index 859922b0bf..08ca6e51b0 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestRequirementAnalysis.java +++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestRequirementAnalysis.java @@ -12,34 +12,35 @@ 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) { @@ -64,21 +65,10 @@ public class TestRequirementAnalysis extends TmfAbstractAnalysisModule { @Override public Iterable getAnalysisRequirements() { - Map 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 requirements = ImmutableSet.of( + AnalysisRequirementFactory.REQUIREMENT_1, + AnalysisRequirementFactory.REQUIREMENT_3); - return requirements.values(); + return requirements; } } diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java index 0031c70439..46fc16bb0f 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java +++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java @@ -37,7 +37,6 @@ import org.eclipse.tracecompass.common.core.NonNullUtils; 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; @@ -508,9 +507,9 @@ public abstract class TmfAbstractAnalysisModule extends TmfComponent 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 information = requirement.getInformation(); if (!information.isEmpty()) { builder.append("\n"); //$NON-NLS-1$ diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/messages.properties b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/messages.properties index f154208ca0..7bc522fcab 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/messages.properties +++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/messages.properties @@ -19,7 +19,7 @@ TmfAbstractAnalysisModule_LabelId=ID 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}" diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventFieldRequirement.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventFieldRequirement.java index 3e2973e711..f3b9005773 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventFieldRequirement.java +++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventFieldRequirement.java @@ -10,6 +10,7 @@ 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; @@ -27,9 +28,6 @@ import com.google.common.collect.Multimap; */ 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; @@ -44,7 +42,7 @@ public class TmfAnalysisEventFieldRequirement extends TmfAnalysisRequirement { * The list of event field names the trace must have */ public TmfAnalysisEventFieldRequirement(String eventName, Collection fields) { - this(eventName, fields, ValuePriorityLevel.OPTIONAL); + this(eventName, fields, PriorityLevel.OPTIONAL); } /** @@ -61,15 +59,16 @@ public class TmfAnalysisEventFieldRequirement extends TmfAnalysisRequirement { * A level associated with all the values * @throws IllegalArgumentException if no event names are provided */ - public TmfAnalysisEventFieldRequirement(String eventName, Collection fields, ValuePriorityLevel level) { - super(TYPE_EVENT_FIELD, fields, level); + public TmfAnalysisEventFieldRequirement(String eventName, Collection fields, PriorityLevel level) { + super(fields, level); fEventName = eventName; } @Override public boolean test(ITmfTrace trace) { if ((trace instanceof ITmfTraceWithPreDefinedEvents)) { - Set mandatoryValues = getValues(ValuePriorityLevel.MANDATORY); + // TODO Implement for all levels of requirements + Set mandatoryValues = getPriorityLevel().equals(PriorityLevel.MANDATORY) ? getValues() : Collections.EMPTY_SET; if (mandatoryValues.isEmpty()) { return true; } diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventRequirement.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventRequirement.java index e87c392fd1..2424082f7c 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventRequirement.java +++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventRequirement.java @@ -9,6 +9,8 @@ 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; @@ -31,8 +33,8 @@ public class TmfAnalysisEventRequirement extends TmfAnalysisRequirement { * @param eventNames * The list of event names the trace must have */ - public TmfAnalysisEventRequirement(Iterable eventNames) { - super(TmfAnalysisRequirement.TYPE_EVENT, eventNames, ValuePriorityLevel.OPTIONAL); + public TmfAnalysisEventRequirement(Collection eventNames) { + super(eventNames, PriorityLevel.OPTIONAL); } /** @@ -44,16 +46,17 @@ public class TmfAnalysisEventRequirement extends TmfAnalysisRequirement { * @param level * A level associated with all the values */ - public TmfAnalysisEventRequirement(Iterable eventNames, ValuePriorityLevel level) { - super(TmfAnalysisRequirement.TYPE_EVENT, eventNames, level); + public TmfAnalysisEventRequirement(Collection eventNames, PriorityLevel level) { + super(eventNames, level); } @Override public boolean test(ITmfTrace trace) { + // TODO: implement for all levels if (trace instanceof ITmfTraceWithPreDefinedEvents) { Set traceEvents = TmfEventTypeCollectionHelper.getEventNames(((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes()); - Set mandatoryValues = getValues(ValuePriorityLevel.MANDATORY); + Set mandatoryValues = getPriorityLevel().equals(PriorityLevel.MANDATORY) ? getValues() : Collections.EMPTY_SET; return traceEvents.containsAll(mandatoryValues); } diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisRequirement.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisRequirement.java index 369437703b..b1d20fb563 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisRequirement.java +++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisRequirement.java @@ -1,189 +1,76 @@ /******************************************************************************* - * 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 { - /** - * 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 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 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 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 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 values, PriorityLevel level) { + fLevel = level; + fValues.addAll(values); } /** @@ -196,28 +83,6 @@ public class TmfAnalysisRequirement implements Predicate { 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. * @@ -225,27 +90,7 @@ public class TmfAnalysisRequirement implements Predicate { */ public Set 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 getValues(ValuePriorityLevel level) { - synchronized (fValues) { - Set values = new HashSet<>(); - for (Entry entry : fValues.entrySet()) { - if (entry.getValue() == level) { - values.add(entry.getKey()); - } - } - return values; + return ImmutableSet.copyOf(fValues); } } @@ -259,16 +104,12 @@ public class TmfAnalysisRequirement implements Predicate { } /** - * 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; } /** @@ -280,22 +121,11 @@ public class TmfAnalysisRequirement implements Predicate { */ @Override public boolean test(ITmfTrace trace) { - switch (fType) { - case TYPE_EVENT: - if (trace instanceof ITmfTraceWithPreDefinedEvents) { - Set traceEvents = TmfEventTypeCollectionHelper.getEventNames(((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes()); - Set 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$ } } diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisRequirementHelper.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisRequirementHelper.java deleted file mode 100644 index 4bf28174fe..0000000000 --- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisRequirementHelper.java +++ /dev/null @@ -1,128 +0,0 @@ -/******************************************************************************* - * 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 getRequirementValues(IAnalysisRequirementProvider provider, String type) { - Set 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 getRequirementValues(IAnalysisRequirementProvider provider, String type, ValuePriorityLevel level) { - Set 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 getRequirementValuesMap(Iterable providers) { - SetMultimap 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 getRequirementValuesMap(Iterable providers, ValuePriorityLevel level) { - SetMultimap 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; - } -}