[jboss-svn-commits] JBL Code SVN: r18568 - in labs/jbossrules/trunk/drools-analytics/src: main/resources/org/drools/analytics and 3 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Sat Feb 23 12:28:12 EST 2008
Author: Rikkola
Date: 2008-02-23 12:28:12 -0500 (Sat, 23 Feb 2008)
New Revision: 18568
Added:
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/Incompatibility.java
labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incompatibility/
labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incompatibility/Restrictions.drl
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incompatibility/
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incompatibility/IncompatibilityBase.java
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incompatibility/IncompatibilityRestrictionsTest.java
Modified:
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/CauseType.java
Log:
1. JBRULES-1476: Check for overlaps.
2. JBRULES-1486: Rules for incompatible restrictions.
3. New rules to subsumption.
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/CauseType.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/CauseType.java 2008-02-23 10:06:19 UTC (rev 18567)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/CauseType.java 2008-02-23 17:28:12 UTC (rev 18568)
@@ -16,6 +16,7 @@
public static final CauseType CONSTRAINT = new CauseType(11);
public static final CauseType CONSEQUENCE = new CauseType(12);
public static final CauseType SUBSUMPTION = new CauseType(13);
+ public static final CauseType OPPOSITES = new CauseType(14);
public final int index;
Added: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/Incompatibility.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/Incompatibility.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/Incompatibility.java 2008-02-23 17:28:12 UTC (rev 18568)
@@ -0,0 +1,52 @@
+package org.drools.analytics.report.components;
+
+/**
+ *
+ * Two causes are opposites.
+ *
+ * @author Toni Rikkola
+ */
+public class Incompatibility implements Cause {
+
+ private static int index = 0;
+
+ private int id = index++;
+
+ private Cause left;
+ private Cause right;
+
+ public Incompatibility(Cause left, Cause right) {
+ this.left = left;
+ this.right = right;
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public CauseType getCauseType() {
+ return CauseType.OPPOSITES;
+ }
+
+ public Cause getLeft() {
+ return left;
+ }
+
+ public void setLeft(Cause left) {
+ this.left = left;
+ }
+
+ public Cause getRight() {
+ return right;
+ }
+
+ public void setRight(Cause right) {
+ this.right = right;
+ }
+
+ @Override
+ public String toString() {
+ return "(" + getLeft() + ") and (" + getRight()
+ + ") are opposites.";
+ }
+}
Added: labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incompatibility/Restrictions.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incompatibility/Restrictions.drl (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incompatibility/Restrictions.drl 2008-02-23 17:28:12 UTC (rev 18568)
@@ -0,0 +1,429 @@
+#created on: 23.02.2008
+package org.drools.analytics.incompatibility
+
+#list any import classes here.
+import org.drools.analytics.components.LiteralRestriction;
+import org.drools.analytics.components.Field.FieldType;
+import org.drools.analytics.report.components.Cause;
+import org.drools.analytics.report.components.MissingRange;
+import org.drools.analytics.report.components.AnalyticsMessage;
+import org.drools.analytics.report.components.Severity;
+import org.drools.analytics.report.components.MessageType;
+import org.drools.analytics.report.components.Incompatibility;
+import org.drools.analytics.dao.AnalyticsResult;
+
+import org.drools.base.evaluators.Operator;
+
+#declare any global variables here
+global AnalyticsResult result;
+
+#
+# If two LiteralRestrictions are in conflict.
+#
+# Depandencies: None
+# Example: Pattern1( a == "b", a != "b" )
+#
+rule "Incompatibility LiteralRestrictions"
+ when
+ $left :LiteralRestriction(
+ # Not >= and <=, because ( a <=, a >= ) works.
+ # And not < or > because they are handled in a separate rule.
+ ( operator != Operator.GREATER_OR_EQUAL || != Operator.LESS_OR_EQUAL || != Operator.LESS || != Operator.GREATER )
+ )
+
+ $right :LiteralRestriction(
+ fieldId == $left.fieldId,
+ valueType == $left.valueType,
+ id != $left.id,
+ # Operator needs to be reversed to what the other one has.
+ eval( operator == MissingRange.getReversedOperator( $left.getOperator() ))
+ )
+
+ eval( $left.compareValues( $right ) == 0 )
+
+ # Check that there is not already a pair with these values.
+ not Incompatibility(
+ left == $left,
+ right == $right
+ )
+ not Incompatibility(
+ right == $left,
+ left == $right
+ )
+ then
+ insert( new Incompatibility( $left, $right ));
+end
+
+#
+# If two LiteralRestrictions are in conflict.
+#
+# Depandencies: None
+# Example: Pattern( a >= 10 && a < 10 )
+#
+rule "Incompatibility LiteralRestrictions with ranges, greater or equal - less"
+ when
+ $left :LiteralRestriction(
+ operator == Operator.GREATER_OR_EQUAL
+ )
+
+ $right :LiteralRestriction(
+ restrictionType == $left.restrictionType,
+ fieldId == $left.fieldId,
+ valueType == $left.valueType,
+ operator == Operator.LESS,
+ id != $left.id
+ )
+
+ eval( $left.compareValues( $right ) == 0 )
+
+ # Check that there is not already a pair with these values.
+ not Incompatibility(
+ left == $left,
+ right == $right
+ )
+ not Incompatibility(
+ right == $left,
+ left == $right
+ )
+ then
+ insert( new Incompatibility( $left, $right ));
+end
+
+#
+# If two LiteralRestrictions are in conflict.
+#
+# Depandencies: None
+# Example: Pattern( a > 10 && a <= 10 )
+#
+rule "Incompatibility LiteralRestrictions with ranges, greater - less or equal"
+ when
+ $left :LiteralRestriction(
+ operator == Operator.GREATER
+ )
+
+ $right :LiteralRestriction(
+ restrictionType == $left.restrictionType,
+ fieldId == $left.fieldId,
+ valueType == $left.valueType,
+ operator == Operator.LESS_OR_EQUAL,
+ id != $left.id
+ )
+
+ eval( $left.compareValues( $right ) == 0 )
+
+ # Check that there is not already a pair with these values.
+ not Incompatibility(
+ left == $left,
+ right == $right
+ )
+ not Incompatibility(
+ right == $left,
+ left == $right
+ )
+ then
+ insert( new Incompatibility( $left, $right ));
+end
+
+
+#
+# If two LiteralRestrictions are in conflict.
+#
+# Depandencies: None
+# Example: Pattern( a < 10 && a > 9 )
+#
+rule "Incompatibility LiteralRestrictions with ranges, less - greater for ints and dates"
+ when
+ $left :LiteralRestriction(
+ operator == Operator.LESS,
+ ( valueType == Field.FieldType.INT || == Field.FieldType.DATE )
+ )
+
+ $right :LiteralRestriction(
+ restrictionType == $left.restrictionType,
+ fieldId == $left.fieldId,
+ valueType == $left.valueType,
+ operator == Operator.GREATER,
+ id != $left.id
+ )
+
+ eval( $left.compareValues( $right ) == 1 )
+
+ # Check that there is not already a pair with these values.
+ not Incompatibility(
+ left == $left,
+ right == $right
+ )
+ not Incompatibility(
+ right == $left,
+ left == $right
+ )
+ then
+ insert( new Incompatibility( $left, $right ));
+end
+
+#
+# If two LiteralRestrictions are in conflict.
+#
+# Depandencies: None
+# Example: Pattern( a >= 10 && a <= 9 )
+#
+rule "Incompatibility LiteralRestrictions with ranges, less or equal - greater or equal for ints and dates"
+ when
+ $left :LiteralRestriction(
+ operator == Operator.GREATER_OR_EQUAL,
+ ( valueType == Field.FieldType.INT || == Field.FieldType.DATE )
+ )
+
+ $right :LiteralRestriction(
+ restrictionType == $left.restrictionType,
+ fieldId == $left.fieldId,
+ valueType == $left.valueType,
+ operator == Operator.LESS_OR_EQUAL,
+ id != $left.id
+ )
+
+ eval( $left.compareValues( $right ) == 1 )
+
+ # Check that there is not already a pair with these values.
+ not Incompatibility(
+ left == $left,
+ right == $right
+ )
+ not Incompatibility(
+ right == $left,
+ left == $right
+ )
+ then
+ insert( new Incompatibility( $left, $right ));
+end
+
+/*
+#
+# If two LiteralRestrictions are in conflict.
+#
+# Type: Error
+# Depandencies: None
+# Example: IncorencePattern( a < 1 && a == 10 )
+#
+rule "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible equality less or equal"
+ when
+ $r1 :LiteralRestriction(
+ operator == Operator.EQUAL
+ )
+
+ $r2 :LiteralRestriction(
+ patternId == $r1.patternId,
+ restrictionType == $r1.restrictionType,
+ fieldId == $r1.fieldId,
+ valueType == $r1.valueType,
+ ( operator == Operator.LESS_OR_EQUAL || == Operator.LESS || == Operator.EQUAL ),
+ id != $r1.id
+ )
+
+ eval( $r1.compareValues( $r2 ) == 1 )
+
+ # There is a problem if both of these are in the same PatternPossibility.
+ $pp :PatternPossibility(
+ items contains $r1,
+ items contains $r2
+ )
+
+ $p :Pattern( id == $pp.patternId )
+ then
+ Collection list = new ArrayList();
+ list.add( $r1 );
+ list.add( $r2 );
+
+ result.add( new AnalyticsMessage(
+ Severity.ERROR,
+ MessageType.INCOHERENCE,
+ $p,
+ "Restriction " + $r1 + " and " + $r2 +
+ "are in conflict. Because of this, pattern that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two LiteralRestrictions are in conflict.
+#
+# Type: Error
+# Depandencies: None
+# Example: IncorencePattern( a > 10 && a == 1 )
+#
+rule "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible equality greater"
+ when
+ $r1 :LiteralRestriction(
+ ( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL )
+ )
+
+ $r2 :LiteralRestriction(
+ patternId == $r1.patternId,
+ restrictionType == $r1.restrictionType,
+ fieldId == $r1.fieldId,
+ valueType == $r1.valueType,
+ operator == Operator.EQUAL,
+ id != $r1.id
+ )
+
+ eval( $r1.compareValues( $r2 ) == 1 )
+
+ # There is a problem if both of these are in the same PatternPossibility.
+ $pp :PatternPossibility(
+ items contains $r1,
+ items contains $r2
+ )
+
+ $p :Pattern( id == $pp.patternId )
+ then
+ Collection list = new ArrayList();
+ list.add( $r1 );
+ list.add( $r2 );
+
+ result.add( new AnalyticsMessage(
+ Severity.ERROR,
+ MessageType.INCOHERENCE,
+ $p,
+ "Restriction " + $r1 + " and " + $r2 +
+ "are in conflict. Because of this, pattern that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two LiteralRestrictions are in conflict.
+#
+# Type: Error
+# Depandencies: None
+# Example: IncorencePattern( a < "12-Dec-2007", a > "12-Dec-2007" )
+#
+rule "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible range"
+ when
+ $r1 :LiteralRestriction(
+ operator == Operator.LESS
+ )
+
+ $r2 :LiteralRestriction(
+ patternId == $r1.patternId,
+ restrictionType == $r1.restrictionType,
+ fieldId == $r1.fieldId,
+ valueType == $r1.valueType,
+ operator == Operator.GREATER,
+ id != $r1.id
+ )
+
+ eval( $r1.compareValues( $r2 ) == 0 )
+
+ # There is a problem if both of these are in the same PatternPossibility.
+ $pp :PatternPossibility(
+ items contains $r1,
+ items contains $r2
+ )
+
+ $p :Pattern( id == $pp.patternId )
+ then
+ Collection list = new ArrayList();
+ list.add( $r1 );
+ list.add( $r2 );
+
+ result.add( new AnalyticsMessage(
+ Severity.ERROR,
+ MessageType.INCOHERENCE,
+ $p,
+ "Restriction " + $r1 + " and " + $r2 +
+ "are in conflict. Because of this, pattern that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two VariableRestrictions are in conflict.
+#
+# Type: Error
+# Depandencies: None
+# Example: IncorencePattern( a contains $o, a not contains $o )
+#
+rule "Incoherent VariableRestrictions in pattern possibility"
+ when
+ $r1 :VariableRestriction(
+ # Not >= and <=, because ( a <=, a >= ) works.
+ # And not < or > because they are handled in a separete rule.
+ ( operator != Operator.GREATER_OR_EQUAL || != Operator.LESS_OR_EQUAL || != Operator.LESS || != Operator.GREATER )
+ )
+
+ $r2 :VariableRestriction(
+ patternId == $r1.patternId,
+ fieldId == $r1.fieldId,
+ id != $r1.id,
+ variable.objectId == $r1.variable.objectId,
+ variable.objectType == $r1.variable.objectType,
+ # Operator needs to be reversed to what the other one has.
+ eval( operator == MissingRange.getReversedOperator( $r1.getOperator() ))
+ )
+
+ # There is a problem if both of these are in the same PatternPossibility.
+ $pp :PatternPossibility(
+ items contains $r1,
+ items contains $r2
+ )
+
+ $p :Pattern( id == $pp.patternId )
+ then
+ Collection list = new ArrayList();
+ list.add( $r1 );
+ list.add( $r2 );
+
+ result.add( new AnalyticsMessage(
+ Severity.ERROR,
+ MessageType.INCOHERENCE,
+ $p,
+ "Restriction " + $r1 + " and " + $r2 +
+ "are in conflict. Because of this, pattern that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two VariableRestrictions are in conflict.
+#
+# Type: Error
+# Depandencies: None
+# Example: IncorencePattern( a > $var, a < $var )
+#
+rule "Incoherent VariableRestrictions in pattern possibility, impossible range"
+ when
+ $r1 :VariableRestriction(
+ operator == Operator.LESS
+ )
+
+ $r2 :VariableRestriction(
+ patternId == $r1.patternId,
+ fieldId == $r1.fieldId,
+ operator == Operator.GREATER,
+ variable.objectId == $r1.variable.objectId,
+ variable.objectType == $r1.variable.objectType,
+ id != $r1.id
+ )
+
+ # There is a problem if both of these are in the same PatternPossibility.
+ $pp :PatternPossibility(
+ items contains $r1,
+ items contains $r2
+ )
+
+ $p :Pattern( id == $pp.patternId )
+ then
+ Collection list = new ArrayList();
+ list.add( $r1 );
+ list.add( $r2 );
+
+ result.add( new AnalyticsMessage(
+ Severity.ERROR,
+ MessageType.INCOHERENCE,
+ $p,
+ "Restriction " + $r1 + " and " + $r2 +
+ "are in conflict. Because of this, pattern that contains them can never be satisfied.",
+ list
+ ) );
+end
+*/
\ No newline at end of file
Added: labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incompatibility/IncompatibilityBase.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incompatibility/IncompatibilityBase.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incompatibility/IncompatibilityBase.java 2008-02-23 17:28:12 UTC (rev 18568)
@@ -0,0 +1,56 @@
+package org.drools.analytics.incompatibility;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import org.drools.analytics.TestBase;
+import org.drools.analytics.report.components.Cause;
+import org.drools.analytics.report.components.CauseType;
+import org.drools.analytics.report.components.Incompatibility;
+
+public class IncompatibilityBase extends TestBase {
+
+ public void testDummy() {
+ // this is needed as eclipse will try to run this and produce a failure
+ // if its not here.
+ assertTrue(true);
+ }
+
+ /**
+ * Creates redundancy map from Redundancy objects, one rule may have several
+ * redundancy dependencies.
+ *
+ * @param iter
+ * @return
+ */
+ protected Map<Cause, Set<Cause>> createOppositesMap(CauseType type,
+ Iterator<Object> iter) {
+
+ Map<Cause, Set<Cause>> map = new HashMap<Cause, Set<Cause>>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Incompatibility) {
+ Incompatibility r = (Incompatibility) o;
+
+ if (r.getLeft().getCauseType() == type) {
+ Cause left = r.getLeft();
+ Cause right = r.getRight();
+
+ if (map.containsKey(left)) {
+ Set<Cause> set = map.get(left);
+ set.add(right);
+ } else {
+ Set<Cause> set = new HashSet<Cause>();
+ set.add(right);
+ map.put(left, set);
+ }
+ }
+ }
+ }
+
+ return map;
+ }
+}
Added: labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incompatibility/IncompatibilityRestrictionsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incompatibility/IncompatibilityRestrictionsTest.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incompatibility/IncompatibilityRestrictionsTest.java 2008-02-23 17:28:12 UTC (rev 18568)
@@ -0,0 +1,230 @@
+package org.drools.analytics.incompatibility;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import org.drools.StatelessSession;
+import org.drools.StatelessSessionResult;
+import org.drools.analytics.TestBase;
+import org.drools.analytics.components.LiteralRestriction;
+import org.drools.analytics.report.components.Cause;
+import org.drools.analytics.report.components.CauseType;
+import org.drools.base.RuleNameMatchesAgendaFilter;
+import org.drools.base.evaluators.MatchesEvaluatorsDefinition;
+import org.drools.base.evaluators.Operator;
+
+public class IncompatibilityRestrictionsTest extends IncompatibilityBase {
+
+ public void testLiteralRestrictionIncompatibility() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incompatibility LiteralRestrictions"));
+
+ Collection<Object> data = new ArrayList<Object>();
+
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setFieldId(0);
+ r1.setOperator(Operator.EQUAL);
+ r1.setValue("1");
+
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setFieldId(0);
+ r2.setOperator(Operator.NOT_EQUAL);
+ r2.setValue("1");
+
+ LiteralRestriction r3 = new LiteralRestriction();
+ r3.setFieldId(0);
+ r3.setOperator(Operator.EQUAL);
+ r3.setValue("1.0");
+
+ LiteralRestriction r4 = new LiteralRestriction();
+ r4.setFieldId(0);
+ r4.setOperator(Operator.NOT_EQUAL);
+ r4.setValue("1.0");
+
+ LiteralRestriction r5 = new LiteralRestriction();
+ r5.setFieldId(0);
+ r5.setOperator(MatchesEvaluatorsDefinition.MATCHES);
+ r5.setValue("foo");
+
+ LiteralRestriction r6 = new LiteralRestriction();
+ r6.setFieldId(0);
+ r6.setOperator(MatchesEvaluatorsDefinition.NOT_MATCHES);
+ r6.setValue("foo");
+
+ data.add(r1);
+ data.add(r2);
+ data.add(r3);
+ data.add(r4);
+ data.add(r5);
+ data.add(r6);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<Cause, Set<Cause>> map = createOppositesMap(CauseType.RESTRICTION,
+ sessionResult.iterateObjects());
+
+ assertTrue((TestBase.causeMapContains(map, r1, r2) ^ TestBase
+ .causeMapContains(map, r2, r1)));
+ assertTrue((TestBase.causeMapContains(map, r3, r4) ^ TestBase
+ .causeMapContains(map, r4, r3)));
+ assertTrue((TestBase.causeMapContains(map, r5, r6) ^ TestBase
+ .causeMapContains(map, r6, r5)));
+
+ if (!map.isEmpty()) {
+ fail("More incompatibilities than was expected.");
+ }
+ }
+
+ public void testLiteralRestrictionIncompatibilityWithRangesGreaterOrEqualAndLess()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incompatibility LiteralRestrictions with ranges, greater or equal - less"));
+
+ Collection<Object> data = new ArrayList<Object>();
+
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setFieldId(0);
+ r1.setOperator(Operator.GREATER_OR_EQUAL);
+ r1.setValue("1");
+
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setFieldId(0);
+ r2.setOperator(Operator.LESS);
+ r2.setValue("1");
+
+ data.add(r1);
+ data.add(r2);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<Cause, Set<Cause>> map = createOppositesMap(CauseType.RESTRICTION,
+ sessionResult.iterateObjects());
+
+ assertTrue((TestBase.causeMapContains(map, r1, r2) ^ TestBase
+ .causeMapContains(map, r2, r1)));
+
+ if (!map.isEmpty()) {
+ fail("More incompatibilities than was expected.");
+ }
+ }
+
+ public void testLiteralRestrictionIncompatibilityWithRangesGreaterAndLessOrEqual()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incompatibility LiteralRestrictions with ranges, greater - less or equal"));
+
+ Collection<Object> data = new ArrayList<Object>();
+
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setFieldId(0);
+ r1.setOperator(Operator.GREATER);
+ r1.setValue("1");
+
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setFieldId(0);
+ r2.setOperator(Operator.LESS_OR_EQUAL);
+ r2.setValue("1");
+
+ data.add(r1);
+ data.add(r2);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<Cause, Set<Cause>> map = createOppositesMap(CauseType.RESTRICTION,
+ sessionResult.iterateObjects());
+
+ assertTrue((TestBase.causeMapContains(map, r1, r2) ^ TestBase
+ .causeMapContains(map, r2, r1)));
+
+ if (!map.isEmpty()) {
+ fail("More incompatibilities than was expected.");
+ }
+ }
+
+ public void testLiteralRestrictionIncompatibilityWithRangesLessAndGreaterForIntsAndDates()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incompatibility LiteralRestrictions with ranges, less - greater for ints and dates"));
+
+ Collection<Object> data = new ArrayList<Object>();
+
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setFieldId(0);
+ r1.setOperator(Operator.GREATER);
+ r1.setValue("0");
+
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setFieldId(0);
+ r2.setOperator(Operator.LESS);
+ r2.setValue("1");
+
+ data.add(r1);
+ data.add(r2);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<Cause, Set<Cause>> map = createOppositesMap(CauseType.RESTRICTION,
+ sessionResult.iterateObjects());
+
+ assertTrue((TestBase.causeMapContains(map, r1, r2) ^ TestBase
+ .causeMapContains(map, r2, r1)));
+
+ if (!map.isEmpty()) {
+ fail("More incompatibility than was expected.");
+ }
+ }
+
+ public void testLiteralRestrictionIncompatibilityWithRangesLessOrEqualAndGreaterOrEqualForIntsAndDates()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incompatibility LiteralRestrictions with ranges, less or equal - greater or equal for ints and dates"));
+
+ Collection<Object> data = new ArrayList<Object>();
+
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setFieldId(0);
+ r1.setOperator(Operator.GREATER_OR_EQUAL);
+ r1.setValue("1");
+
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setFieldId(0);
+ r2.setOperator(Operator.LESS_OR_EQUAL);
+ r2.setValue("0");
+
+ data.add(r1);
+ data.add(r2);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<Cause, Set<Cause>> map = createOppositesMap(CauseType.RESTRICTION,
+ sessionResult.iterateObjects());
+
+ assertTrue((TestBase.causeMapContains(map, r1, r2) ^ TestBase
+ .causeMapContains(map, r2, r1)));
+
+ if (!map.isEmpty()) {
+ fail("More incompatibilities than was expected.");
+ }
+ }
+}
More information about the jboss-svn-commits
mailing list