[jboss-svn-commits] JBL Code SVN: r16673 - in labs/jbossrules/trunk/drools-analytics: src/main/java/org/drools/analytics and 8 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Mon Nov 19 03:02:57 EST 2007
Author: Rikkola
Date: 2007-11-19 03:02:57 -0500 (Mon, 19 Nov 2007)
New Revision: 16673
Added:
labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incoherence/
labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incoherence/Patterns.drl
labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incoherence/Restrictions.drl
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incoherence/
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incoherence/IncoherentPatternsTest.java
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incoherence/IncoherentRestrictionsTest.java
labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/incoherence/
labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/incoherence/PatternsTest.drl
labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/incoherence/RestrictionsTest.drl
Modified:
labs/jbossrules/trunk/drools-analytics/.classpath
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/PatternSolver.java
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/RuleSolver.java
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/AnalyticsRule.java
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/LiteralRestriction.java
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Pattern.java
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Variable.java
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/AnalyticsMessageBase.java
Log:
Incoherence tests for patterns and restrictions.
Modified: labs/jbossrules/trunk/drools-analytics/.classpath
===================================================================
--- labs/jbossrules/trunk/drools-analytics/.classpath 2007-11-19 06:19:59 UTC (rev 16672)
+++ labs/jbossrules/trunk/drools-analytics/.classpath 2007-11-19 08:02:57 UTC (rev 16673)
@@ -6,7 +6,5 @@
<classpathentry excluding="**" kind="src" output="src/test/resources" path="src/test/resources"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/>
- <classpathentry kind="var" path="AGITAR_TEST_LIB"/>
- <classpathentry kind="var" path="AGITAR_MOCK_OBJECTS5"/>
<classpathentry kind="output" path="target/classes"/>
</classpath>
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/PatternSolver.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/PatternSolver.java 2007-11-19 06:19:59 UTC (rev 16672)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/PatternSolver.java 2007-11-19 08:02:57 UTC (rev 16673)
@@ -14,7 +14,7 @@
public PatternSolver(Pattern pattern) {
super(OperatorDescr.Type.OR);
- this.pattern = (Pattern) pattern.clone();
+ this.pattern = pattern;
}
public Pattern getPattern() {
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/RuleSolver.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/RuleSolver.java 2007-11-19 06:19:59 UTC (rev 16672)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/RuleSolver.java 2007-11-19 08:02:57 UTC (rev 16673)
@@ -14,7 +14,7 @@
public RuleSolver(AnalyticsRule rule) {
super(OperatorDescr.Type.OR);
- this.rule = (AnalyticsRule) rule.clone();
+ this.rule = (AnalyticsRule) rule;
}
public AnalyticsRule getRule() {
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/AnalyticsRule.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/AnalyticsRule.java 2007-11-19 06:19:59 UTC (rev 16672)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/AnalyticsRule.java 2007-11-19 08:02:57 UTC (rev 16673)
@@ -6,8 +6,7 @@
*
* @author Toni Rikkola
*/
-public class AnalyticsRule extends AnalyticsComponent implements Cloneable,
- Cause {
+public class AnalyticsRule extends AnalyticsComponent implements Cause {
private static int index = 0;
@@ -65,20 +64,6 @@
}
@Override
- public Object clone() {
- AnalyticsRule clone = new AnalyticsRule();
-
- clone.setRuleName(ruleName);
- clone.setRuleId(ruleId);
- clone.setRuleSalience(ruleSalience);
- clone.setRuleAgendaGroup(ruleAgendaGroup);
- clone.setConsequence(consequence);
- clone.setLineNumber(lineNumber);
-
- return clone;
- }
-
- @Override
public String toString() {
return "Rule '" + ruleName + "'";
}
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/LiteralRestriction.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/LiteralRestriction.java 2007-11-19 06:19:59 UTC (rev 16672)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/LiteralRestriction.java 2007-11-19 08:02:57 UTC (rev 16673)
@@ -3,6 +3,7 @@
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
+import java.util.zip.DataFormatException;
import org.drools.analytics.report.components.Cause;
@@ -28,6 +29,53 @@
return Restriction.RestrictionType.LITERAL;
}
+ /**
+ * Compares two LiteralRestrictions by value.
+ *
+ * @param restriction
+ * Restriction that this object is compared to.
+ * @return a negative integer, zero, or a positive integer as this object is
+ * less than, equal to, or greater than the specified object.
+ * @throws DataFormatException
+ * If data was not supported.
+ */
+ public int compareValues(LiteralRestriction restriction)
+ throws DataFormatException {
+ if (restriction.getValueType() != valueType) {
+ throw new DataFormatException(
+ "Value types did not match. Value type "
+ + restriction.getValueType() + " was compared to "
+ + valueType);
+ }
+ switch (valueType) {
+ case DATE:
+ return dateValue.compareTo(restriction.getDateValue());
+ case DOUBLE:
+ if (doubleValue > restriction.getDoubleValue()) {
+ return 1;
+ } else if (doubleValue < restriction.getDoubleValue()) {
+ return -1;
+ } else {
+ return 0;
+ }
+ case INT:
+ if (intValue > restriction.getIntValue()) {
+ return 1;
+ } else if (intValue < restriction.getIntValue()) {
+ return -1;
+ } else {
+ return 0;
+ }
+ case STRING:
+ return stringValue.compareTo(restriction.getValueAsString());
+ default:
+ throw new DataFormatException(
+ "Value types did not match. Value type "
+ + restriction.getValueType() + " was compared to "
+ + valueType);
+ }
+ }
+
public Object getValueAsObject() {
switch (valueType) {
case BOOLEAN:
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Pattern.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Pattern.java 2007-11-19 06:19:59 UTC (rev 16672)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Pattern.java 2007-11-19 08:02:57 UTC (rev 16673)
@@ -6,7 +6,7 @@
*
* @author Toni Rikkola
*/
-public class Pattern extends AnalyticsComponent implements Cloneable, Cause {
+public class Pattern extends AnalyticsComponent implements Cause {
private static final long serialVersionUID = 5852308145251025423L;
@@ -100,21 +100,6 @@
}
@Override
- public Object clone() {
- Pattern clone = new Pattern();
- clone.setRuleId(ruleId);
- clone.setClassId(classId);
- clone.setName(name);
- clone.setSourceType(sourceType);
- clone.setSourceId(sourceId);
- clone.setPatternNot(isPatternNot);
- clone.setPatternExists(isPatternExists);
- clone.setPatternForall(isPatternForall);
-
- return clone;
- }
-
- @Override
public String toString() {
return "Pattern, name: " + name;
}
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Variable.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Variable.java 2007-11-19 06:19:59 UTC (rev 16672)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Variable.java 2007-11-19 08:02:57 UTC (rev 16673)
@@ -65,4 +65,9 @@
public void setObjectName(String objectName) {
this.objectName = objectName;
}
+
+ @Override
+ public String toString() {
+ return "Variable name: " + name;
+ }
}
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/AnalyticsMessageBase.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/AnalyticsMessageBase.java 2007-11-19 06:19:59 UTC (rev 16672)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/report/components/AnalyticsMessageBase.java 2007-11-19 08:02:57 UTC (rev 16673)
@@ -39,7 +39,7 @@
}
public static enum MessageType {
- NOT_SPECIFIED, RANGE_CHECK, MISSING_EQUALITY, REDUNDANCY, SUBSUMPTION, MISSING_COMPONENT, OPTIMISATION
+ NOT_SPECIFIED, RANGE_CHECK, MISSING_EQUALITY, REDUNDANCY, SUBSUMPTION, MISSING_COMPONENT, OPTIMISATION, INCOHERENCE
}
protected Severity severity;
Added: labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incoherence/Patterns.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incoherence/Patterns.drl (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incoherence/Patterns.drl 2007-11-19 08:02:57 UTC (rev 16673)
@@ -0,0 +1,540 @@
+#created on: 14.11.2007
+package org.drools.analytics.incoherence
+
+#list any import classes here.
+import org.drools.analytics.components.AnalyticsRule;
+import org.drools.analytics.components.LiteralRestriction;
+import org.drools.analytics.components.PatternPossibility;
+import org.drools.analytics.components.RulePossibility;
+import org.drools.analytics.components.Pattern;
+import org.drools.analytics.components.VariableRestriction;
+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.dao.AnalyticsResult;
+
+import java.util.Collection;
+import java.util.ArrayList;
+
+import org.drools.base.evaluators.Operator;
+
+#declare any global variables here
+global AnalyticsResult result;
+
+#
+# If two Patterns are in conflict.
+#
+# Type: Warning
+# Example:
+# IncorencePattern( a == 1 )
+# not IncorencePattern( a == 1 )
+#
+rule "Incoherent Patterns in rule possibility"
+ when
+ $r1 :LiteralRestriction(
+ patternIsNot == true
+ )
+
+ $r2 :LiteralRestriction(
+ ruleId == $r1.ruleId,
+ patternIsNot == false,
+ restrictionType == $r1.restrictionType,
+ fieldId == $r1.fieldId,
+ valueType == $r1.valueType,
+ operator == $r1.operator
+ )
+
+ eval( $r1.compareValues( $r2 ) == 0 )
+
+ $pp1 :PatternPossibility(
+ patternId == $r1.patternId
+ )
+
+ $pp2 :PatternPossibility(
+ patternId == $r2.patternId
+ )
+
+ # There is a problem if both of these are in the same RulePossibility.
+ $rp :RulePossibility(
+ items contains $pp1,
+ items contains $pp2
+ )
+
+
+ $p1 :Pattern(
+ id == $r1.patternId
+ )
+
+ $p2 :Pattern(
+ id == $r2.patternId
+ )
+
+ $r :AnalyticsRule(
+ id == $rp.ruleId
+ )
+ then
+ Collection<Cause> list = new ArrayList<Cause>();
+ list.add( $p1 );
+ list.add( $p2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.WARNING,
+ AnalyticsMessage.MessageType.INCOHERENCE,
+ $r,
+ "Pattern " + $p1 + " and " + $p2 +
+ " are in conflict. Because of this, it is possible that the rule that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two Patterns are in conflict.
+#
+# Type: Warning
+# Example:
+# $var :Object()
+# IncorencePattern( a == $var )
+# not IncorencePattern( a == $var )
+#
+rule "Incoherent Patterns in rule possibility, variables"
+ when
+ $r1 :VariableRestriction(
+ patternIsNot == true
+ )
+
+ $r2 :VariableRestriction(
+ ruleId == $r1.ruleId,
+ patternIsNot == false,
+ fieldId == $r1.fieldId,
+ variable.objectId == $r1.variable.objectId,
+ variable.objectType == $r1.variable.objectType,
+ operator == $r1.operator
+ )
+
+ $pp1 :PatternPossibility(
+ patternId == $r1.patternId
+ )
+
+ $pp2 :PatternPossibility(
+ patternId == $r2.patternId
+ )
+
+ # There is a problem if both of these are in the same RulePossibility.
+ $rp :RulePossibility(
+ items contains $pp1,
+ items contains $pp2
+ )
+
+
+ $p1 :Pattern(
+ id == $r1.patternId
+ )
+
+ $p2 :Pattern(
+ id == $r2.patternId
+ )
+
+ $r :AnalyticsRule(
+ id == $rp.ruleId
+ )
+ then
+ Collection<Cause> list = new ArrayList<Cause>();
+ list.add( $p1 );
+ list.add( $p2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.WARNING,
+ AnalyticsMessage.MessageType.INCOHERENCE,
+ $r,
+ "Pattern " + $p1 + " and " + $p2 +
+ " are in conflict. Because of this, it is possible that the rule that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two Patterns are in conflict.
+#
+# Type: Warning
+# Example:
+# IncorencePattern8( a > 11 )
+# not IncorencePattern8( a > 1 )
+#
+rule "Incoherent Patterns in rule possibility, ranges when not conflicts with lesser value"
+ when
+ $r1 :LiteralRestriction(
+ patternIsNot == true,
+ ( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL )
+ )
+
+ $r2 :LiteralRestriction(
+ ruleId == $r1.ruleId,
+ patternIsNot == false,
+ ( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL || == Operator.EQUAL ),
+ fieldId == $r1.fieldId
+ )
+
+ eval( $r1.compareValues( $r2 ) == -1 )
+
+ $pp1 :PatternPossibility(
+ patternId == $r1.patternId
+ )
+
+ $pp2 :PatternPossibility(
+ patternId == $r2.patternId
+ )
+
+ # There is a problem if both of these are in the same RulePossibility.
+ $rp :RulePossibility(
+ items contains $pp1,
+ items contains $pp2
+ )
+
+ $p1 :Pattern(
+ id == $r1.patternId
+ )
+
+ $p2 :Pattern(
+ id == $r2.patternId
+ )
+
+ $r :AnalyticsRule(
+ id == $rp.ruleId
+ )
+ then
+ Collection<Cause> list = new ArrayList<Cause>();
+ list.add( $p1 );
+ list.add( $p2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.WARNING,
+ AnalyticsMessage.MessageType.INCOHERENCE,
+ $r,
+ "Pattern " + $p1 + " and " + $p2 +
+ " are in conflict. Because of this, it is possible that the rule that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two Patterns are in conflict.
+#
+# Type: Warning
+# Example:
+# IncorencePattern( a < 1 )
+# not IncorencePattern( a < 11 )
+#
+rule "Incoherent Patterns in rule possibility, ranges when not conflicts with greater value"
+ when
+ $r1 :LiteralRestriction(
+ patternIsNot == true,
+ ( operator == Operator.LESS || == Operator.LESS_OR_EQUAL )
+ )
+
+ $r2 :LiteralRestriction(
+ ruleId == $r1.ruleId,
+ patternIsNot == false,
+ ( operator == Operator.LESS || == Operator.LESS_OR_EQUAL || == Operator.EQUAL ),
+ fieldId == $r1.fieldId
+ )
+
+ eval( $r1.compareValues( $r2 ) == 1 )
+
+ $pp1 :PatternPossibility(
+ patternId == $r1.patternId
+ )
+
+ $pp2 :PatternPossibility(
+ patternId == $r2.patternId
+ )
+
+ # There is a problem if both of these are in the same RulePossibility.
+ $rp :RulePossibility(
+ items contains $pp1,
+ items contains $pp2
+ )
+
+ $p1 :Pattern(
+ id == $r1.patternId
+ )
+
+ $p2 :Pattern(
+ id == $r2.patternId
+ )
+
+ $r :AnalyticsRule(
+ id == $rp.ruleId
+ )
+ then
+ Collection<Cause> list = new ArrayList<Cause>();
+ list.add( $p1 );
+ list.add( $p2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.WARNING,
+ AnalyticsMessage.MessageType.INCOHERENCE,
+ $r,
+ "Pattern " + $p1 + " and " + $p2 +
+ " are in conflict. Because of this, it is possible that the rule that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two Patterns are in conflict.
+#
+# Type: Warning
+# Example:
+# IncoherencePattern( a >= 1 )
+# not IncoherencePattern( a != 1 )
+#
+rule "Incoherent Patterns in rule possibility, ranges when not conflicts with equal or unequal value"
+ when
+ $r1 :LiteralRestriction(
+ patternIsNot == true,
+ operator == Operator.NOT_EQUAL
+ )
+
+ $r2 :LiteralRestriction(
+ ruleId == $r1.ruleId,
+ patternIsNot == false,
+ # It is also a problem if the value is NOT_EQUAL, but there is already a rule for that.
+ ( operator != Operator.EQUAL && != Operator.NOT_EQUAL ),
+ fieldId == $r1.fieldId
+ )
+
+ eval( $r1.compareValues( $r2 ) == 0 )
+
+ $pp1 :PatternPossibility(
+ patternId == $r1.patternId
+ )
+
+ $pp2 :PatternPossibility(
+ patternId == $r2.patternId
+ )
+
+ # There is a problem if both of these are in the same RulePossibility.
+ $rp :RulePossibility(
+ items contains $pp1,
+ items contains $pp2
+ )
+
+ $p1 :Pattern(
+ id == $r1.patternId
+ )
+
+ $p2 :Pattern(
+ id == $r2.patternId
+ )
+
+ $r :AnalyticsRule(
+ id == $rp.ruleId
+ )
+then
+ Collection<Cause> list = new ArrayList<Cause>();
+ list.add( $p1 );
+ list.add( $p2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.WARNING,
+ AnalyticsMessage.MessageType.INCOHERENCE,
+ $r,
+ "Pattern " + $p1 + " and " + $p2 +
+ " are in conflict. Because of this, it is possible that the rule that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two Patterns are in conflict.
+#
+# Type: Warning
+# Example:
+# IncoherencePattern15( a >= $var )
+# not IncoherencePattern15( a != $var )
+#
+rule "Incoherent Patterns in rule possibility, ranges when not conflicts with equal or unequal variables"
+ when
+ $r1 :VariableRestriction(
+ patternIsNot == true,
+ operator == Operator.NOT_EQUAL
+ )
+
+ $r2 :VariableRestriction(
+ ruleId == $r1.ruleId,
+ patternIsNot == false,
+ fieldId == $r1.fieldId,
+ variable.objectId == $r1.variable.objectId,
+ variable.objectType == $r1.variable.objectType,
+ # It is also a problem if the value is NOT_EQUAL, but there is already a rule for that.
+ ( operator != Operator.EQUAL && != Operator.NOT_EQUAL )
+ )
+
+ $pp1 :PatternPossibility(
+ patternId == $r1.patternId
+ )
+
+ $pp2 :PatternPossibility(
+ patternId == $r2.patternId
+ )
+
+ # There is a problem if both of these are in the same RulePossibility.
+ $rp :RulePossibility(
+ items contains $pp1,
+ items contains $pp2
+ )
+
+ $p1 :Pattern(
+ id == $r1.patternId
+ )
+
+ $p2 :Pattern(
+ id == $r2.patternId
+ )
+
+ $r :AnalyticsRule(
+ id == $rp.ruleId
+ )
+then
+ Collection<Cause> list = new ArrayList<Cause>();
+ list.add( $p1 );
+ list.add( $p2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.WARNING,
+ AnalyticsMessage.MessageType.INCOHERENCE,
+ $r,
+ "Pattern " + $p1 + " and " + $p2 +
+ " are in conflict. Because of this, it is possible that the rule that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two Patterns are in conflict.
+#
+# Type: Warning
+# Example:
+# IncoherencePattern13( a == $var )
+# not IncoherencePattern13( a >= $var )
+#
+rule "Incoherent Patterns in rule possibility, ranges when not conflicts with equal value"
+ when
+ $r1 :LiteralRestriction(
+ patternIsNot == true,
+ ( operator == Operator.LESS_OR_EQUAL || == Operator.GREATER_OR_EQUAL )
+ )
+
+ $r2 :LiteralRestriction(
+ ruleId == $r1.ruleId,
+ patternIsNot == false,
+ operator == Operator.EQUAL,
+ fieldId == $r1.fieldId
+ )
+
+ eval( $r1.compareValues( $r2 ) == 0 )
+
+ $pp1 :PatternPossibility(
+ patternId == $r1.patternId
+ )
+
+ $pp2 :PatternPossibility(
+ patternId == $r2.patternId
+ )
+
+ # There is a problem if both of these are in the same RulePossibility.
+ $rp :RulePossibility(
+ items contains $pp1,
+ items contains $pp2
+ )
+
+ $p1 :Pattern(
+ id == $r1.patternId
+ )
+
+ $p2 :Pattern(
+ id == $r2.patternId
+ )
+
+ $r :AnalyticsRule(
+ id == $rp.ruleId
+ )
+then
+ Collection<Cause> list = new ArrayList<Cause>();
+ list.add( $p1 );
+ list.add( $p2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.WARNING,
+ AnalyticsMessage.MessageType.INCOHERENCE,
+ $r,
+ "Pattern " + $p1 + " and " + $p2 +
+ " are in conflict. Because of this, it is possible that the rule that contains them can never be satisfied.",
+ list
+ ) );
+end
+
+#
+# If two Patterns are in conflict.
+#
+# Type: Warning
+# Example:
+# IncoherencePattern13( a == $var )
+# not IncoherencePattern13( a >= $var )
+#
+rule "Incoherent Patterns in rule possibility, ranges when not conflicts with equal variable"
+ when
+ $r1 :VariableRestriction(
+ patternIsNot == true,
+ # Equal is also a problem, but there is already a rule for that.
+ ( operator == Operator.LESS_OR_EQUAL || == Operator.GREATER_OR_EQUAL )
+ )
+
+ $r2 :VariableRestriction(
+ ruleId == $r1.ruleId,
+ patternIsNot == false,
+ fieldId == $r1.fieldId,
+ variable.objectId == $r1.variable.objectId,
+ variable.objectType == $r1.variable.objectType,
+ operator == Operator.EQUAL
+ )
+
+ $pp1 :PatternPossibility(
+ patternId == $r1.patternId
+ )
+
+ $pp2 :PatternPossibility(
+ patternId == $r2.patternId
+ )
+
+ # There is a problem if both of these are in the same RulePossibility.
+ $rp :RulePossibility(
+ items contains $pp1,
+ items contains $pp2
+ )
+
+ $p1 :Pattern(
+ id == $r1.patternId
+ )
+
+ $p2 :Pattern(
+ id == $r2.patternId
+ )
+
+ $r :AnalyticsRule(
+ id == $rp.ruleId
+ )
+then
+ Collection<Cause> list = new ArrayList<Cause>();
+ list.add( $p1 );
+ list.add( $p2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.WARNING,
+ AnalyticsMessage.MessageType.INCOHERENCE,
+ $r,
+ "Pattern " + $p1 + " and " + $p2 +
+ " are in conflict. Because of this, it is possible that the rule that contains them can never be satisfied.",
+ list
+ ) );
+end
\ No newline at end of file
Added: labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incoherence/Restrictions.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incoherence/Restrictions.drl (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/incoherence/Restrictions.drl 2007-11-19 08:02:57 UTC (rev 16673)
@@ -0,0 +1,245 @@
+#created on: 13.11.2007
+package org.drools.analytics.incoherence
+
+#list any import classes here.
+import org.drools.analytics.components.LiteralRestriction;
+import org.drools.analytics.components.PatternPossibility;
+import org.drools.analytics.components.Pattern;
+import org.drools.analytics.components.VariableRestriction;
+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.dao.AnalyticsResult;
+
+import java.util.Collection;
+import java.util.ArrayList;
+
+import org.drools.base.evaluators.Operator;
+
+#declare any global variables here
+global AnalyticsResult result;
+
+#
+# If two LiteralRestrictions are in conflict.
+#
+# Type: Error
+# Example: IncorencePattern1( a == "b", a != "b" )
+#
+rule "Incoherent LiteralRestrictions in pattern possibility"
+ when
+ $r1 :LiteralRestriction(
+ # 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 :LiteralRestriction(
+ patternId == $r1.patternId,
+ restrictionType == $r1.restrictionType,
+ fieldId == $r1.fieldId,
+ valueType == $r1.valueType,
+ id != $r1.id,
+ # 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<Cause> list = new ArrayList<Cause>();
+ list.add( $r1 );
+ list.add( $r2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.ERROR,
+ AnalyticsMessage.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
+# Example: IncorencePattern( a > 10 && a < -10 )
+#
+rule "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible ranges"
+ when
+ $r1 :LiteralRestriction(
+ ( operator == Operator.GREATER_OR_EQUAL || == Operator.GREATER )
+ )
+
+ $r2 :LiteralRestriction(
+ patternId == $r1.patternId,
+ restrictionType == $r1.restrictionType,
+ fieldId == $r1.fieldId,
+ valueType == $r1.valueType,
+ ( operator == Operator.LESS_OR_EQUAL || == Operator.LESS ),
+ 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<Cause> list = new ArrayList<Cause>();
+ list.add( $r1 );
+ list.add( $r2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.ERROR,
+ AnalyticsMessage.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
+# 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<Cause> list = new ArrayList<Cause>();
+ list.add( $r1 );
+ list.add( $r2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.ERROR,
+ AnalyticsMessage.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
+# 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<Cause> list = new ArrayList<Cause>();
+ list.add( $r1 );
+ list.add( $r2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.ERROR,
+ AnalyticsMessage.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
+# 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<Cause> list = new ArrayList<Cause>();
+ list.add( $r1 );
+ list.add( $r2 );
+
+ result.save( new AnalyticsMessage(
+ AnalyticsMessage.Severity.ERROR,
+ AnalyticsMessage.MessageType.INCOHERENCE,
+ $p,
+ "Restriction " + $r1 + " and " + $r2 +
+ "are in conflict. Because of this, pattern that contains them can never be satisfied.",
+ list
+ ) );
+end
Added: labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incoherence/IncoherentPatternsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incoherence/IncoherentPatternsTest.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incoherence/IncoherentPatternsTest.java 2007-11-19 08:02:57 UTC (rev 16673)
@@ -0,0 +1,356 @@
+package org.drools.analytics.incoherence;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.drools.StatelessSession;
+import org.drools.analytics.TestBase;
+import org.drools.analytics.components.AnalyticsRule;
+import org.drools.analytics.dao.AnalyticsDataFactory;
+import org.drools.analytics.dao.AnalyticsResult;
+import org.drools.analytics.report.components.AnalyticsMessage;
+import org.drools.analytics.report.components.AnalyticsMessageBase;
+import org.drools.base.RuleNameMatchesAgendaFilter;
+
+/**
+ *
+ * @author Toni Rikkola
+ *
+ */
+public class IncoherentPatternsTest extends TestBase {
+
+ public void testIncoherentPatternsInRulePossibility() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Patterns.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent Patterns in rule possibility"));
+
+ AnalyticsDataFactory.clearAnalyticsData();
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("PatternsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.WARNING).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ AnalyticsRule rule = (AnalyticsRule) ((AnalyticsMessage) o)
+ .getFaulty();
+ rulesThatHadErrors.add(rule.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 1"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 2"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 7"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentPatternsInRulePossibilityVariables()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Patterns.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent Patterns in rule possibility, variables"));
+
+ AnalyticsDataFactory.clearAnalyticsData();
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("PatternsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.WARNING).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ AnalyticsRule rule = (AnalyticsRule) ((AnalyticsMessage) o)
+ .getFaulty();
+ rulesThatHadErrors.add(rule.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 3"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 4"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 5"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 6"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentPatternsInRulePossibilityRangesLess()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Patterns.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent Patterns in rule possibility, ranges when not conflicts with lesser value"));
+
+ AnalyticsDataFactory.clearAnalyticsData();
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("PatternsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.WARNING).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ AnalyticsRule rule = (AnalyticsRule) ((AnalyticsMessage) o)
+ .getFaulty();
+ rulesThatHadErrors.add(rule.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 8"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 12"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentPatternsInRulePossibilityRangesGreater()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Patterns.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent Patterns in rule possibility, ranges when not conflicts with greater value"));
+
+ AnalyticsDataFactory.clearAnalyticsData();
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("PatternsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.WARNING).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ AnalyticsRule rule = (AnalyticsRule) ((AnalyticsMessage) o)
+ .getFaulty();
+ rulesThatHadErrors.add(rule.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 9"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 14"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentPatternsInRulePossibilityRangesEqualOrUnequal()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Patterns.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent Patterns in rule possibility, ranges when not conflicts with equal or unequal value"));
+
+ AnalyticsDataFactory.clearAnalyticsData();
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("PatternsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.WARNING).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ AnalyticsRule rule = (AnalyticsRule) ((AnalyticsMessage) o)
+ .getFaulty();
+ rulesThatHadErrors.add(rule.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 10"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 15"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentPatternsInRulePossibilityRangesEqualOrUnequalVariables()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Patterns.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent Patterns in rule possibility, ranges when not conflicts with equal or unequal variables"));
+
+ AnalyticsDataFactory.clearAnalyticsData();
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("PatternsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.WARNING).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ AnalyticsRule rule = (AnalyticsRule) ((AnalyticsMessage) o)
+ .getFaulty();
+ rulesThatHadErrors.add(rule.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 11"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentPatternsInRulePossibilityRangesEqualValue()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Patterns.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent Patterns in rule possibility, ranges when not conflicts with equal value"));
+
+ AnalyticsDataFactory.clearAnalyticsData();
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("PatternsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.WARNING).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ AnalyticsRule rule = (AnalyticsRule) ((AnalyticsMessage) o)
+ .getFaulty();
+ rulesThatHadErrors.add(rule.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 16"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentPatternsInRulePossibilityRangesEqualVariable()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Patterns.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent Patterns in rule possibility, ranges when not conflicts with equal variable"));
+
+ AnalyticsDataFactory.clearAnalyticsData();
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("PatternsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.WARNING).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ AnalyticsRule rule = (AnalyticsRule) ((AnalyticsMessage) o)
+ .getFaulty();
+ rulesThatHadErrors.add(rule.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent patterns 13"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+}
Added: labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incoherence/IncoherentRestrictionsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incoherence/IncoherentRestrictionsTest.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/incoherence/IncoherentRestrictionsTest.java 2007-11-19 08:02:57 UTC (rev 16673)
@@ -0,0 +1,219 @@
+package org.drools.analytics.incoherence;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.drools.StatelessSession;
+import org.drools.analytics.TestBase;
+import org.drools.analytics.components.Pattern;
+import org.drools.analytics.dao.AnalyticsDataFactory;
+import org.drools.analytics.dao.AnalyticsResult;
+import org.drools.analytics.report.components.AnalyticsMessage;
+import org.drools.analytics.report.components.AnalyticsMessageBase;
+import org.drools.base.RuleNameMatchesAgendaFilter;
+
+/**
+ *
+ * @author Toni Rikkola
+ *
+ */
+public class IncoherentRestrictionsTest extends TestBase {
+
+ public void testIncoherentLiteralRestrictionsInPatternPossibility()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent LiteralRestrictions in pattern possibility"));
+
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("RestrictionsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.ERROR).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ Pattern pattern = (Pattern) ((AnalyticsMessage) o).getFaulty();
+ rulesThatHadErrors.add(pattern.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 1"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 2"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentLiteralRestrictionsInPatternPossibilityImpossibleRanges()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible ranges"));
+
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("RestrictionsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.ERROR).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ Pattern pattern = (Pattern) ((AnalyticsMessage) o).getFaulty();
+ rulesThatHadErrors.add(pattern.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 8"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentLiteralRestrictionsInPatternPossibilityImpossibleRange()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible range"));
+
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("RestrictionsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.ERROR).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ Pattern pattern = (Pattern) ((AnalyticsMessage) o).getFaulty();
+ rulesThatHadErrors.add(pattern.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 7"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentVariableRestrictionsInPatternPossibility()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent VariableRestrictions in pattern possibility"));
+
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("RestrictionsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.ERROR).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ Pattern pattern = (Pattern) ((AnalyticsMessage) o).getFaulty();
+ rulesThatHadErrors.add(pattern.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 3"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 4"));
+ assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 5"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testIncoherentVariableRestrictionsInPatternPossibilityImpossibleRange()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session
+ .setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Incoherent VariableRestrictions in pattern possibility, impossible range"));
+
+ Collection<? extends Object> testData = getTestData(this.getClass()
+ .getResourceAsStream("RestrictionsTest.drl"));
+
+ AnalyticsDataFactory.clearAnalyticsResult();
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ session.executeWithResults(testData);
+
+ Iterator<AnalyticsMessageBase> iter = result.getBySeverity(
+ AnalyticsMessageBase.Severity.ERROR).iterator();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof AnalyticsMessage) {
+ Pattern pattern = (Pattern) ((AnalyticsMessage) o).getFaulty();
+ rulesThatHadErrors.add(pattern.getRuleName());
+ }
+ }
+
+ assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 6"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+}
\ No newline at end of file
Added: labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/incoherence/PatternsTest.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/incoherence/PatternsTest.drl (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/incoherence/PatternsTest.drl 2007-11-19 08:02:57 UTC (rev 16673)
@@ -0,0 +1,141 @@
+#created on: 18.10.2007
+package org.drools.analytics.consequence
+
+#list any import classes here.
+
+#declare any global variables here
+
+
+rule "Incoherent patterns 1"
+ when
+ IncoherencePattern1( a == 1 )
+ not IncoherencePattern1( a == 1 )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 2"
+ when
+ IncoherencePattern2( a matches "text" )
+ not IncoherencePattern2( a matches "text" )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 3"
+ when
+ $o :Object()
+ IncoherencePattern3( a not contains $o )
+ not IncoherencePattern3( a not contains $o )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 4"
+ when
+ $list :ListItem()
+ IncoherencePattern4( a memberOf $list )
+ not IncoherencePattern4( a memberOf $list )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 5"
+ when
+ $var :Object()
+ IncoherencePattern5( a != $var )
+ not IncoherencePattern5( a != $var )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 6"
+ when
+ $var :Object()
+ IncoherencePattern6( a > $var )
+ not IncoherencePattern6( a > $var )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 7"
+ when
+ IncoherencePattern7( a > 11 )
+ not IncoherencePattern7( a > 11 )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 8"
+ when
+ IncoherencePattern8( a > 11 )
+ not IncoherencePattern8( a > 1 )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 9"
+ when
+ IncoherencePattern9( a <= 1 )
+ not IncoherencePattern9( a < 11 )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 10"
+ when
+ IncoherencePattern10( a < 1 )
+ not IncoherencePattern10( a != 1 )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 11"
+ when
+ $var :Object()
+ IncoherencePattern11( a < $var )
+ not IncoherencePattern11( a != $var )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 12"
+ when
+ IncoherencePattern12( a == 1 )
+ not IncoherencePattern12( a > 0 )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 13"
+ when
+ $var :Object()
+ IncoherencePattern13( a == $var )
+ not IncoherencePattern13( a >= $var )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 14"
+ when
+ IncoherencePattern14( a == -1 )
+ not IncoherencePattern14( a < 0 )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 15"
+ when
+ IncoherencePattern15( a >= 1 )
+ not IncoherencePattern15( a != 1 )
+ then
+ # Test
+end
+
+rule "Incoherent patterns 16"
+ when
+ IncoherencePattern16( a == 101 )
+ not IncoherencePattern16( a >= 101 )
+ then
+ # Test
+end
Added: labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/incoherence/RestrictionsTest.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/incoherence/RestrictionsTest.drl (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/incoherence/RestrictionsTest.drl 2007-11-19 08:02:57 UTC (rev 16673)
@@ -0,0 +1,68 @@
+#created on: 18.10.2007
+package org.drools.analytics.consequence
+
+#list any import classes here.
+
+#declare any global variables here
+
+
+rule "Incoherent restrictions 1"
+ when
+ IncoherencePattern1( a == 1, a != 2 )
+ then
+ # Test
+end
+
+rule "Incoherent restrictions 2"
+ when
+ IncoherencePattern2( a matches "text", a not matches "text" )
+ then
+ # Test
+end
+
+rule "Incoherent restrictions 3"
+ when
+ $o :Object
+ IncoherencePattern3( a contains $o, a not contains $o )
+ then
+ # Test
+end
+
+rule "Incoherent restrictions 4"
+ when
+ $list :ListItem
+ IncoherencePattern4( a memberOf $list, a not memberOf $list )
+ then
+ # Test
+end
+
+rule "Incoherent restrictions 5"
+ when
+ $var :Object
+ IncoherencePattern5( a == $var, a != $var )
+ then
+ # Test
+end
+
+rule "Incoherent restrictions 6"
+ when
+ $var :Object
+ IncoherencePattern6( a > $var, a < $var )
+ then
+ # Test
+end
+
+rule "Incoherent restrictions 7"
+ when
+ IncoherencePattern7( a > 11, a < 11 )
+ then
+ # Test
+end
+
+rule "Incoherent restrictions 8"
+ when
+ IncoherencePattern8( a > 10, a < 0 )
+ then
+ # Test
+end
+
More information about the jboss-svn-commits
mailing list