requirements: Implement all level for event names and fields

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 <gbastien+lttng@versatic.net>

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 07c069e72fa553b1c8a12bc9ff0c6753597fbbc9..a6b3f4785aacffe56babe95ea2ef84fcf270ac68 100644 (file)
--- 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 2808a7e9dfbb795c49ffefd745a53592be92f059..8c6e68bf4fa2b43db87f6872c5994027a6909cb9 100644 (file)
--- 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 d9acbf8fce0b26dd0c812b515d8e42ab407f825e..d6e0e86fc68c47106916e2941624f7354862e78c 100644 (file)
--- 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<String> 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<String> 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 59ec2a6a798d28d75346191f49c4a6b5b5d7d0b9..6fc4c4f5291b0b215425972891e4d124474ba8bc 100644 (file)
--- 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<String> traceEvents = TmfEventTypeCollectionHelper.getEventNames(((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes());
-            Set<String> mandatoryValues = getPriorityLevel().equals(PriorityLevel.MANDATORY) ? getValues() : Collections.EMPTY_SET;
-            return traceEvents.containsAll(mandatoryValues);
+        if (!(trace instanceof ITmfTraceWithPreDefinedEvents)) {
+            return true;
         }
 
-        return true;
+        Set<String> traceEvents = TmfEventTypeCollectionHelper.getEventNames(((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes());
+        Set<String> 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$
+        }
     }
 
 }