From 56433619fd77bbb18ebe806099d926d7be3e170f Mon Sep 17 00:00:00 2001 From: =?utf8?q?Genevi=C3=A8ve=20Bastien?= Date: Wed, 11 May 2016 13:31:19 -0400 Subject: [PATCH] requirements: Implement all level for event names and fields MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit All requirement priority levels are implemented for the 2 built-in types of requirement: TmfAnalysisEventRequirement and TmfAnalysisEventFieldRequirement Change-Id: I513f9a767ac32c23d8fa27702834271008a65d51 Signed-off-by: Geneviève Bastien --- .../AnalysisEventFieldRequirementTest.java | 72 ++++++++++++++++++- .../AnalysisEventRequirementTest.java | 40 +++++++++++ .../TmfAnalysisEventFieldRequirement.java | 66 +++++++++++++---- .../TmfAnalysisEventRequirement.java | 26 +++++-- 4 files changed, 181 insertions(+), 23 deletions(-) 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 07c069e72f..a6b3f4785a 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 @@ -152,14 +152,84 @@ public class AnalysisEventFieldRequirementTest { assertFalse(req.test(trace)); /* Test case that all events need to have the given fields */ - req = new TmfAnalysisEventFieldRequirement("", ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2)); + req = new TmfAnalysisEventFieldRequirement("", ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2), PriorityLevel.MANDATORY); assertTrue(req.test(trace)); + /* Test case that all events need to have the given fields */ + req = new TmfAnalysisEventFieldRequirement("", ImmutableSet.of(EVENT2_FIELD1), PriorityLevel.MANDATORY); + assertFalse(req.test(trace)); + /* Test case that empty list of event fields behaves like Event Requirements */ req = new TmfAnalysisEventFieldRequirement(EVENT1, checkNotNull(Collections.EMPTY_LIST)); assertTrue(req.test(trace)); } + /** + * Test with {@link PriorityLevel#AT_LEAST_ONE} requirements + */ + @Test + public void testAtLeastOneRequirements() { + /* Test at least one requirement */ + TmfAbstractAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.AT_LEAST_ONE); + assertTrue(req.test(trace)); + + req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2), PriorityLevel.AT_LEAST_ONE); + assertTrue(req.test(trace)); + + /* EVENT3 is not part of the trace. Test case that the event is part of the trace */ + req = new TmfAnalysisEventFieldRequirement(EVENT3, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2), PriorityLevel.AT_LEAST_ONE); + 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), PriorityLevel.AT_LEAST_ONE); + assertTrue(req.test(trace)); + + /* Test case that all events need to have at least one of the given fields */ + req = new TmfAnalysisEventFieldRequirement("", ImmutableSet.of(EVENT1_FIELD1, EVENT2_FIELD2), PriorityLevel.AT_LEAST_ONE); + assertTrue(req.test(trace)); + + /* Test case that all events need to have the given fields */ + req = new TmfAnalysisEventFieldRequirement("", ImmutableSet.of(EVENT2_FIELD1), PriorityLevel.AT_LEAST_ONE); + assertFalse(req.test(trace)); + + /* Test case that empty list of event fields behaves like Event Requirements */ + req = new TmfAnalysisEventFieldRequirement(EVENT1, checkNotNull(Collections.EMPTY_LIST), PriorityLevel.AT_LEAST_ONE); + assertTrue(req.test(trace)); + } + + /** + * Test with {@link PriorityLevel#ALL_OR_NOTHING} requirements + */ + @Test + public void testAllOrNothingRequirements() { + /* Test at least one requirement */ + TmfAbstractAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.ALL_OR_NOTHING); + assertTrue(req.test(trace)); + + req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2), PriorityLevel.ALL_OR_NOTHING); + assertTrue(req.test(trace)); + + /* EVENT3 is not part of the trace. Test case that the event is part of the trace */ + req = new TmfAnalysisEventFieldRequirement(EVENT3, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2), PriorityLevel.ALL_OR_NOTHING); + assertTrue(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), PriorityLevel.ALL_OR_NOTHING); + assertFalse(req.test(trace)); + + /* Test case that all events need to have either all or none of the given fields */ + req = new TmfAnalysisEventFieldRequirement("", ImmutableSet.of(EVENT1_FIELD1, EVENT2_FIELD2), PriorityLevel.ALL_OR_NOTHING); + assertFalse(req.test(trace)); + + /* Test case that all events need to have the given fields */ + req = new TmfAnalysisEventFieldRequirement("", ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.ALL_OR_NOTHING); + assertTrue(req.test(trace)); + + /* Test case that empty list of event fields behaves like Event Requirements */ + req = new TmfAnalysisEventFieldRequirement(EVENT1, checkNotNull(Collections.EMPTY_LIST), PriorityLevel.ALL_OR_NOTHING); + assertTrue(req.test(trace)); + } + /** * Test event requirements on a trace with no pre-defined events. They * should all pass 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 2808a7e9df..8c6e68bf4f 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 @@ -122,6 +122,46 @@ public class AnalysisEventRequirementTest { assertFalse(req.test(fTrace)); } + /** + * Test with {@link PriorityLevel#AT_LEAST_ONE} requirements + */ + @Test + public void testAtLeastOneRequirements() { + /* Test mandatory requirement */ + TmfAbstractAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1), PriorityLevel.AT_LEAST_ONE); + assertTrue(req.test(fTrace)); + + req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2), PriorityLevel.AT_LEAST_ONE); + assertTrue(req.test(fTrace)); + + /* Event 3 is not an event of the trace */ + req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2, EVENT3), PriorityLevel.AT_LEAST_ONE); + assertTrue(req.test(fTrace)); + + req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT3), PriorityLevel.AT_LEAST_ONE); + assertFalse(req.test(fTrace)); + } + + /** + * Test with {@link PriorityLevel#ALL_OR_NOTHING} requirements + */ + @Test + public void testAllOrNothingRequirements() { + /* Test mandatory requirement */ + TmfAbstractAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1), PriorityLevel.ALL_OR_NOTHING); + assertTrue(req.test(fTrace)); + + req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2), PriorityLevel.ALL_OR_NOTHING); + assertTrue(req.test(fTrace)); + + /* Event 3 is not an event of the trace */ + req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2, EVENT3), PriorityLevel.ALL_OR_NOTHING); + assertFalse(req.test(fTrace)); + + req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT3), PriorityLevel.ALL_OR_NOTHING); + assertTrue(req.test(fTrace)); + } + /** * Test event requirements on a trace with no pre-defined events. They * should all pass 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 d9acbf8fce..d6e0e86fc6 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,7 +10,7 @@ package org.eclipse.tracecompass.tmf.core.analysis.requirements; import java.util.Collection; -import java.util.Collections; +import java.util.HashSet; import java.util.Set; import org.eclipse.jdt.annotation.NonNull; @@ -66,25 +66,61 @@ public class TmfAnalysisEventFieldRequirement extends TmfAbstractAnalysisRequire @Override public boolean test(ITmfTrace trace) { - if ((trace instanceof ITmfTraceWithPreDefinedEvents)) { - // TODO Implement for all levels of requirements - Set mandatoryValues = getPriorityLevel().equals(PriorityLevel.MANDATORY) ? getValues() : Collections.EMPTY_SET; - if (mandatoryValues.isEmpty()) { - return true; - } - Multimap<@NonNull String, @NonNull String> traceEvents = - TmfEventTypeCollectionHelper.getEventFieldNames((((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes())); - if (fEventName.isEmpty()) { + if (!(trace instanceof ITmfTraceWithPreDefinedEvents)) { + return true; + } + + Set values = getValues(); + if (values.isEmpty()) { + return true; + } + + final Multimap<@NonNull String, @NonNull String> traceEvents = TmfEventTypeCollectionHelper.getEventFieldNames((((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes())); + + if (fEventName.isEmpty()) { + switch(getPriorityLevel()) { + case ALL_OR_NOTHING: return traceEvents.keys().stream().allMatch(eventName -> { - Collection<@NonNull String> fields = traceEvents.get(fEventName); - return fields.containsAll(mandatoryValues); + Collection<@NonNull String> fields = new HashSet<>(traceEvents.get(eventName)); + fields.retainAll(values); + return (fields.size() == 0 || fields.size() == values.size()); }); + case AT_LEAST_ONE: + return traceEvents.keys().stream().allMatch(eventName -> { + Collection<@NonNull String> fields = new HashSet<>(traceEvents.get(eventName)); + fields.retainAll(values); + return fields.size() > 0; + }); + case MANDATORY: + return traceEvents.keys().stream().allMatch(eventName -> { + Collection<@NonNull String> fields = traceEvents.get(eventName); + return fields.containsAll(values); + }); + case OPTIONAL: + return true; + default: + throw new IllegalStateException("Unknown value level: " + getPriorityLevel()); //$NON-NLS-1$ } - Collection<@NonNull String> fields = traceEvents.get(fEventName); - return fields.containsAll(mandatoryValues); } - return true; + + // Check the level for required event only + Collection<@NonNull String> fields = traceEvents.get(fEventName); + switch(getPriorityLevel()) { + case ALL_OR_NOTHING: + fields.retainAll(values); + return (fields.size() == 0 || fields.size() == values.size()); + case AT_LEAST_ONE: + fields.retainAll(values); + return fields.size() > 0; + case MANDATORY: + return fields.containsAll(values); + case OPTIONAL: + return true; + default: + throw new IllegalStateException("Unknown value level: " + getPriorityLevel()); //$NON-NLS-1$ + } + } } 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 59ec2a6a79..6fc4c4f529 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 @@ -10,7 +10,6 @@ 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; @@ -53,14 +52,27 @@ public class TmfAnalysisEventRequirement extends TmfAbstractAnalysisRequirement @Override public boolean test(ITmfTrace trace) { - // TODO: implement for all levels - if (trace instanceof ITmfTraceWithPreDefinedEvents) { - Set traceEvents = TmfEventTypeCollectionHelper.getEventNames(((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes()); - Set mandatoryValues = getPriorityLevel().equals(PriorityLevel.MANDATORY) ? getValues() : Collections.EMPTY_SET; - return traceEvents.containsAll(mandatoryValues); + if (!(trace instanceof ITmfTraceWithPreDefinedEvents)) { + return true; } - return true; + Set traceEvents = TmfEventTypeCollectionHelper.getEventNames(((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes()); + Set values = getValues(); + + switch (getPriorityLevel()) { + case ALL_OR_NOTHING: + traceEvents.retainAll(values); + return (traceEvents.size() == 0 || traceEvents.size() == values.size()); + case AT_LEAST_ONE: + traceEvents.retainAll(values); + return traceEvents.size() > 0; + case MANDATORY: + return traceEvents.containsAll(values); + case OPTIONAL: + return true; + default: + throw new IllegalStateException("Unknown value level: " + getPriorityLevel()); //$NON-NLS-1$ + } } } -- 2.34.1