[jboss-svn-commits] JBL Code SVN: r15620 - in labs/jbossrules/trunk/drools-analytics: src/main/java/org/drools/analytics/components and 4 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Sat Oct 6 15:38:53 EDT 2007
Author: Rikkola
Date: 2007-10-06 15:38:52 -0400 (Sat, 06 Oct 2007)
New Revision: 15620
Added:
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/RangeCheckCleanTest.java
Modified:
labs/jbossrules/trunk/drools-analytics/.classpath
labs/jbossrules/trunk/drools-analytics/.project
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/result/Gap.java
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/MissingNumberPattern.java
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/MissingRangesReportVisitor.java
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/RangeCheckCause.java
labs/jbossrules/trunk/drools-analytics/src/main/resources/StaticQualityAnalysis.drl
labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/rangeChecks/Clean.drl
labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/rangeChecks/Patterns.drl
Log:
Some fixes to range checks.
Modified: labs/jbossrules/trunk/drools-analytics/.classpath
===================================================================
--- labs/jbossrules/trunk/drools-analytics/.classpath 2007-10-06 14:55:00 UTC (rev 15619)
+++ labs/jbossrules/trunk/drools-analytics/.classpath 2007-10-06 19:38:52 UTC (rev 15620)
@@ -1,19 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="src" path="src/main/java"/>
- <classpathentry kind="src" path="src/main/resources" excluding="**/*.java"/>
- <classpathentry kind="src" path="src/test/java" output="target/test-classes"/>
- <classpathentry kind="src" path="src/test/resources" output="target/test-classes" excluding="**/*.java"/>
- <classpathentry kind="output" path="target/classes"/>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
- <classpathentry kind="var" path="M2_REPO/org/mvel/mvel14/1.2.7/mvel14-1.2.7.jar"/>
- <classpathentry kind="var" path="M2_REPO/xpp3/xpp3_min/1.1.3.4.O/xpp3_min-1.1.3.4.O.jar"/>
- <classpathentry kind="var" path="M2_REPO/org/eclipse/jdt/core/3.2.3.v_686_R32x/core-3.2.3.v_686_R32x.jar"/>
- <classpathentry kind="var" path="M2_REPO/xml-apis/xml-apis/1.0.b2/xml-apis-1.0.b2.jar" sourcepath="M2_REPO/xml-apis/xml-apis/1.0.b2/xml-apis-1.0.b2-sources.jar"/>
- <classpathentry kind="var" path="M2_REPO/xerces/xercesImpl/2.4.0/xercesImpl-2.4.0.jar" sourcepath="M2_REPO/xerces/xercesImpl/2.4.0/xercesImpl-2.4.0-sources.jar"/>
- <classpathentry kind="var" path="M2_REPO/janino/janino/2.5.10/janino-2.5.10.jar"/>
- <classpathentry kind="var" path="M2_REPO/com/thoughtworks/xstream/xstream/1.2.2/xstream-1.2.2.jar" sourcepath="M2_REPO/com/thoughtworks/xstream/xstream/1.2.2/xstream-1.2.2-sources.jar"/>
- <classpathentry kind="src" path="/drools-core"/>
- <classpathentry kind="var" path="M2_REPO/junit/junit/3.8.1/junit-3.8.1.jar" sourcepath="M2_REPO/junit/junit/3.8.1/junit-3.8.1-sources.jar"/>
- <classpathentry kind="src" path="/drools-compiler"/>
- <classpathentry kind="var" path="M2_REPO/org/antlr/antlr-runtime/3.0/antlr-runtime-3.0.jar"/>
-</classpath>
\ No newline at end of file
+ <classpathentry kind="src" path="src/main/java"/>
+ <classpathentry kind="src" path="src/test/java"/>
+ <classpathentry excluding="**" kind="src" output="src/main/resources" path="src/main/resources"/>
+ <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="output" path="target/classes"/>
+</classpath>
Modified: labs/jbossrules/trunk/drools-analytics/.project
===================================================================
--- labs/jbossrules/trunk/drools-analytics/.project 2007-10-06 14:55:00 UTC (rev 15619)
+++ labs/jbossrules/trunk/drools-analytics/.project 2007-10-06 19:38:52 UTC (rev 15620)
@@ -1,16 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
- <name>drools-analytics</name>
- <comment>A rule production system</comment>
- <projects>
- <project>drools-core</project>
- <project>drools-compiler</project>
- </projects>
- <buildSpec>
- <buildCommand>
- <name>org.eclipse.jdt.core.javabuilder</name>
- </buildCommand>
- </buildSpec>
- <natures>
- <nature>org.eclipse.jdt.core.javanature</nature>
- </natures>
-</projectDescription>
\ No newline at end of file
+ <name>drools-analytics</name>
+ <comment>A rule production system</comment>
+ <projects>
+ <project>drools-core</project>
+ <project>drools-compiler</project>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.maven.ide.eclipse.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.maven.ide.eclipse.maven2Nature</nature>
+ </natures>
+</projectDescription>
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-10-06 14:55:00 UTC (rev 15619)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/LiteralRestriction.java 2007-10-06 19:38:52 UTC (rev 15620)
@@ -15,15 +15,35 @@
private Field.FieldType valueType;
private boolean booleanValue;
+
private int intValue;
+
private double doubleValue;
+
private String stringValue;
+
private Date dateValue;
public RestrictionType getRestrictionType() {
return Restriction.RestrictionType.LITERAL;
}
+ public Object getValueAsObject() {
+ switch (valueType) {
+ case BOOLEAN:
+ return Boolean.valueOf(booleanValue);
+ case DATE:
+ return dateValue;
+ case DOUBLE:
+ return Double.valueOf(doubleValue);
+ case INT:
+ return Integer.valueOf(intValue);
+
+ default:
+ return stringValue;
+ }
+ }
+
public String getValueAsString() {
return stringValue;
}
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/Gap.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/Gap.java 2007-10-06 14:55:00 UTC (rev 15619)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/Gap.java 2007-10-06 19:38:52 UTC (rev 15620)
@@ -73,6 +73,10 @@
return restriction.getValueAsString();
}
+ public Object getValueAsObject() {
+ return restriction.getValueAsObject();
+ }
+
@Override
public String toString() {
return "Gap: (" + field + ") " + getEvaluator() + " "
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/MissingNumberPattern.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/MissingNumberPattern.java 2007-10-06 14:55:00 UTC (rev 15619)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/MissingNumberPattern.java 2007-10-06 19:38:52 UTC (rev 15620)
@@ -1,5 +1,11 @@
package org.drools.analytics.result;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+
import org.drools.analytics.components.Field;
/**
@@ -9,6 +15,8 @@
public class MissingNumberPattern extends MissingRange implements
RangeCheckCause, Comparable {
+ private Field.FieldType valueType;
+
private String value;
public int compareTo(Object another) {
@@ -19,9 +27,11 @@
return Cause.CauseType.RANGE_CHECK_CAUSE;
}
- public MissingNumberPattern(Field field, String evaluator, String value) {
+ public MissingNumberPattern(Field field, String evaluator,
+ Field.FieldType valueType, String value) {
this.field = field;
this.evaluator = evaluator;
+ this.valueType = valueType;
this.value = value;
}
@@ -36,6 +46,39 @@
return value;
}
+ public Object getValueAsObject() {
+ switch (valueType) {
+ case BOOLEAN:
+ return Boolean.valueOf(value);
+ case DATE:
+ try {
+ String fmt = System.getProperty("drools.dateformat");
+ if (fmt == null) {
+ fmt = "dd-MMM-yyyy";
+ }
+
+ return new SimpleDateFormat(fmt, Locale.ENGLISH).parse(value);
+ } catch (ParseException e) {
+ e.printStackTrace();
+ }
+ case DOUBLE:
+ return Double.valueOf(value);
+ case INT:
+ return Integer.valueOf(value);
+
+ default:
+ return value;
+ }
+ }
+
+ public Field.FieldType getValueType() {
+ return valueType;
+ }
+
+ public void setValueType(Field.FieldType valueType) {
+ this.valueType = valueType;
+ }
+
@Override
public String toString() {
return "Missing restriction " + evaluator + " " + value;
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/MissingRangesReportVisitor.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/MissingRangesReportVisitor.java 2007-10-06 14:55:00 UTC (rev 15619)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/MissingRangesReportVisitor.java 2007-10-06 19:38:52 UTC (rev 15620)
@@ -76,23 +76,29 @@
public static Collection<String> visitRestrictionsCollection(
String sourceFolder, Collection<Restriction> restrictions,
Collection<RangeCheckCause> causes) {
- MapTree<String, String> map = new MapTree<String, String>();
+ MapTree<Object, String> map = new MapTree<Object, String>();
for (RangeCheckCause cause : causes) {
- map.put(cause.getValueAsString(), cause.getEvaluator() + " "
+ map.put(cause.getValueAsObject(), cause.getEvaluator() + " "
+ cause.getValueAsString() + " is missing");
}
for (Restriction r : restrictions) {
if (r instanceof LiteralRestriction) {
- LiteralRestriction restriction = (LiteralRestriction) r;
- map.put(restriction.getValueAsString(), restriction
- .getEvaluator()
- + " "
- + restriction.getValueAsString()
- + " "
- + UrlFactory.getRuleUrl(sourceFolder, restriction
- .getRuleId(), restriction.getRuleName()));
+ try {
+ LiteralRestriction restriction = (LiteralRestriction) r;
+
+ map.put(restriction.getValueAsObject(), restriction
+ .getEvaluator()
+ + " "
+ + restriction.getValueAsString()
+ + " "
+ + UrlFactory.getRuleUrl(sourceFolder, restriction
+ .getRuleId(), restriction.getRuleName()));
+ } catch (Exception e) {
+ System.out.println(map);
+ System.out.println(r);
+ }
}
}
@@ -114,30 +120,36 @@
return result;
}
- static class MapTree<K, V> {
- protected Map<K, Set<V>> map = new TreeMap<K, Set<V>>();
+}
- protected void put(K key, V value) {
- if (map.containsKey(key)) {
- Set<V> set = map.get(key);
- set.add(value);
- } else {
- Set<V> set = new TreeSet<V>();
- set.add(value);
- map.put(key, set);
- }
+class MapTree<K, V> {
+ protected Map<K, Set<V>> map = new TreeMap<K, Set<V>>();
+
+ protected void put(K key, V value) {
+ if (map.containsKey(key)) {
+ Set<V> set = map.get(key);
+ set.add(value);
+ } else {
+ Set<V> set = new TreeSet<V>();
+ set.add(value);
+ map.put(key, set);
}
+ }
- protected Collection<V> values() {
- Collection<V> values = new ArrayList<V>();
+ protected Collection<V> values() {
+ Collection<V> values = new ArrayList<V>();
- for (Set<V> set : map.values()) {
- for (V value : set) {
- values.add(value);
- }
+ for (Set<V> set : map.values()) {
+ for (V value : set) {
+ values.add(value);
}
+ }
- return values;
- }
+ return values;
}
+
+ @Override
+ public String toString() {
+ return values().toString();
+ }
}
Modified: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/RangeCheckCause.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/RangeCheckCause.java 2007-10-06 14:55:00 UTC (rev 15619)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/result/RangeCheckCause.java 2007-10-06 19:38:52 UTC (rev 15620)
@@ -10,6 +10,8 @@
public Field getField();
+ public Object getValueAsObject();
+
public String getValueAsString();
public String getEvaluator();
Modified: labs/jbossrules/trunk/drools-analytics/src/main/resources/StaticQualityAnalysis.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/resources/StaticQualityAnalysis.drl 2007-10-06 14:55:00 UTC (rev 15619)
+++ labs/jbossrules/trunk/drools-analytics/src/main/resources/StaticQualityAnalysis.drl 2007-10-06 19:38:52 UTC (rev 15620)
@@ -4,6 +4,18 @@
global AnalysisResult result
+#
+#
+#
+#
+# This file is here as TODO list. It does not work with the current analytics components.
+# - Toni Rikkola -
+#
+#
+#
+#
+#
+
rule "Less than"
when
constraint: Constraint( f:field, o:operator == "<", v:value, r:ruleName, ot:objectType )
Modified: labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/rangeChecks/Clean.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/rangeChecks/Clean.drl 2007-10-06 14:55:00 UTC (rev 15619)
+++ labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/rangeChecks/Clean.drl 2007-10-06 19:38:52 UTC (rev 15620)
@@ -1,7 +1,8 @@
#created on: 24.9.2007
package org.drools.analytics.rangeChecks.cleanUp
-import org.drools.analytics.result.Gap;
+import org.drools.analytics.components.*;
+import org.drools.analytics.result.Gap;
import org.drools.analytics.result.MissingNumberPattern;
import org.drools.analytics.dao.AnalyticsData;
@@ -29,61 +30,395 @@
retract( $g1 );
retract( $g2 );
- MissingNumberPattern mnp = new MissingNumberPattern( $g1.getField(), "==", $g1.getValueAsString() );
+ MissingNumberPattern mnp = new MissingNumberPattern(
+ $g1.getField(),
+ "==",
+ $g1.getField().getFieldType(),
+ $g1.getValueAsString() );
mnp.setFiredRuleName( drools.getRule().getName() );
data.save( mnp );
insert( mnp );
end
-/*
+
#
-# Example: covered ( x > 10 ) and ( x < 100 ) ( x == 50 )
-# reports that ( x > 50 ) and ( x < 50 ) are missing.
+# Example: covered ( x > 10 ), ( x > 70 ) ( x < 100 )and ( x == 50 )
+# reports that ( x < 50 ), ( x > 50 ) and ( x <= 70 ) is missing.
#
-rule "Remove useless gaps"
+rule "Remove useless integer gaps lesser or lesser and equal"
when
- $r1 :LiteralRestriction( fieldType == Field.FieldType.INT )
+ # Covered x > 10
+ $lower :LiteralRestriction(
+ valueType == Field.FieldType.INT,
+ ( evaluator == ">" || == ">=")
+ )
+
+ # Covered x < 100
+ $higher :LiteralRestriction(
+ fieldId == $lower.fieldId,
+ intValue > $lower.intValue,
+ patternIsNot == $lower.patternIsNot,
+ ( evaluator == "<" || == "<=")
+ )
- # gap ( x > 50 )
- $g :Gap(
- evaluator == ">",
- restriction == $r1
+ # No "<" or "<=" restrictions between these two
+ not LiteralRestriction(
+ ( evaluator == "<=" || == "<" ),
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ intValue > $lower.intValue,
+ intValue < $higher.intValue
)
+
+ # gap ( x < 50 ) or ( x > 50 ) or ( x <= 70 )
+ $gap :Gap(
+ restriction.fieldId == $lower.fieldId,
+ restriction.patternIsNot == $lower.patternIsNot,
+ restriction.intValue > $lower.intValue,
+ restriction.intValue < $higher.intValue
+ )
+ then
+ #System.out.println( $lower + " | " + $higher );
+ retract( $gap );
+ data.remove( $gap );
+end
+
+#
+# Example: covered ( x > 10 ), ( x < 70 ) ( x < 100 )and ( x == 50 )
+# reports that ( x < 50 ), ( x > 50 ) and ( x >= 70 ) is missing.
+#
+rule "Remove useless integer gaps greater or greater and equal"
+ when
+ # Covered x > 10
+ $lower :LiteralRestriction(
+ valueType == Field.FieldType.INT,
+ ( evaluator == ">" || == ">=")
+ )
+
+ # Covered x < 100
+ $higher :LiteralRestriction(
+ fieldId == $lower.fieldId,
+ intValue > $lower.intValue,
+ patternIsNot == $lower.patternIsNot,
+ ( evaluator == "<" || == "<=")
+ )
- # covered ( x > 50 )
- $r2 :LiteralRestriction(
- fieldId = $r1.fieldId,
- patternIsNot == $r1.patternIsNot,
- ( evaluator == ">" || == ">=" )
- intValue < $r1.intValue()
+ # No "<" or "<=" restrictions between these two
+ not LiteralRestriction(
+ ( evaluator == ">=" || == ">" ),
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ intValue > $lower.intValue,
+ intValue < $higher.intValue
)
+ # gap ( x < 50 ) or ( x > 50 ) or ( x >= 70 )
+ $gap :Gap(
+ restriction.fieldId == $lower.fieldId,
+ restriction.patternIsNot == $lower.patternIsNot,
+ restriction.intValue > $lower.intValue,
+ restriction.intValue < $higher.intValue
+ )
+ then
+ #System.out.println( $lower + " | " + $higher );
+ retract( $gap );
+ data.remove( $gap );
+end
+
+#
+# Example: covered ( x > 10.0 ), ( x > 70.0 ) ( x < 100.0 )and ( x == 50.0 )
+# reports that ( x < 50.0 ), ( x > 50.0 ) and ( x <= 70.0 ) is missing.
+#
+rule "Remove useless double gaps lesser or lesser and equal"
+ when
+ # Covered x > 10.0
+ $lower :LiteralRestriction(
+ valueType == Field.FieldType.DOUBLE,
+ ( evaluator == ">" || == ">=")
+ )
+
+ # Covered x < 100.0
+ $higher :LiteralRestriction(
+ fieldId == $lower.fieldId,
+ doubleValue > $lower.doubleValue,
+ patternIsNot == $lower.patternIsNot,
+ ( evaluator == "<" || == "<=")
+ )
+
+ # No "<" or "<=" restrictions between these two
not LiteralRestriction(
- fieldId = $r.fieldId,
- patternIsNot == $r.patternIsNot,
- intValue < $r1.intValue(),
- intValue < $r2.intValue()
+ ( evaluator == "<=" || == "<" ),
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ doubleValue > $lower.doubleValue,
+ doubleValue < $higher.doubleValue
)
+
+ # gap ( x < 50.0 ) or ( x > 50.0 ) or ( x <= 70.0 )
+ $gap :Gap(
+ restriction.fieldId == $lower.fieldId,
+ restriction.patternIsNot == $lower.patternIsNot,
+ restriction.doubleValue > $lower.doubleValue,
+ restriction.doubleValue < $higher.doubleValue
+ )
then
- #
- #
- #
- #
- #
- #
- #
- #
+ #System.out.println( $lower + " | " + $higher );
+ retract( $gap );
+ data.remove( $gap );
end
-*/
+#
+# Example: covered ( x > 10.0 ), ( x < 70.0 ) ( x < 100.0 )and ( x == 50.0 )
+# reports that ( x < 50.0 ), ( x > 50.0 ) and ( x >= 70.0 ) is missing.
+#
+rule "Remove useless double gaps greater or greater and equal"
+ when
+ # Covered x > 10.0
+ $lower :LiteralRestriction(
+ valueType == Field.FieldType.DOUBLE,
+ ( evaluator == ">" || == ">=")
+ )
+ # Covered x < 100.0
+ $higher :LiteralRestriction(
+ fieldId == $lower.fieldId,
+ doubleValue > $lower.doubleValue,
+ patternIsNot == $lower.patternIsNot,
+ ( evaluator == "<" || == "<=")
+ )
+
+ # No "<" or "<=" restrictions between these two
+ not LiteralRestriction(
+ ( evaluator == ">=" || == ">" ),
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ doubleValue > $lower.doubleValue,
+ doubleValue < $higher.doubleValue
+ )
+ # gap ( x < 50.0 ) or ( x > 50.0 ) or ( x >= 70.0 )
+ $gap :Gap(
+ restriction.fieldId == $lower.fieldId,
+ restriction.patternIsNot == $lower.patternIsNot,
+ restriction.doubleValue > $lower.doubleValue,
+ restriction.doubleValue < $higher.doubleValue
+ )
+ then
+ #System.out.println( $lower + " | " + $higher );
+ retract( $gap );
+ data.remove( $gap );
+end
+#
+# Example: covered ( x > "01-Oct-2007" ), ( x > "15-Oct-2007" ) ( x < "20-Oct-2007" )and ( x == "10-Oct-2007" )
+# reports that ( x < "10-Oct-2007" ), ( x > "10-Oct-2007" ) and ( x <= "15-Oct-2007" ) is missing.
+#
+rule "Remove useless date gaps lesser or lesser and equal"
+ when
+ # Covered x > "01-Oct-2007"
+ $lower :LiteralRestriction(
+ valueType == Field.FieldType.DATE,
+ ( evaluator == ">" || == ">=")
+ )
+ # Covered x < "20-Oct-2007"
+ $higher :LiteralRestriction(
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ ( evaluator == "<" || == "<="),
+ eval( dateValue.after( $lower.getDateValue() ) )
+ )
+
+ # No "<" or "<=" restrictions between these two
+ not LiteralRestriction(
+ ( evaluator == "<=" || == "<" ),
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ eval( dateValue.after( $lower.getDateValue() ) ),
+ eval( dateValue.before( $higher.getDateValue() ) )
+ )
+ # gap ( x < "10-Oct-2007" ) or ( x > "10-Oct-2007" ) or ( x <= "15-Oct-2007" )
+ $gap :Gap(
+ restriction.fieldId == $lower.fieldId,
+ restriction.patternIsNot == $lower.patternIsNot,
+ eval( restriction.getDateValue().after( $lower.getDateValue() ) ),
+ eval( restriction.getDateValue().before( $higher.getDateValue() ) )
+ )
+ then
+ #System.out.println( $lower + " | " + $higher );
+ retract( $gap );
+ data.remove( $gap );
+end
+#
+# Example: covered ( x > "01-Oct-2007" ), ( x < "15-Oct-2007" ) ( x < "20-Oct-2007" )and ( x == "10-Oct-2007" )
+# reports that ( x < "10-Oct-2007" ), ( x > "10-Oct-2007" ) and ( x >= "15-Oct-2007" ) is missing.
+#
+rule "Remove useless date gaps greater or greater and equal"
+ when
+ # Covered x > "01-Oct-2007"
+ $lower :LiteralRestriction(
+ valueType == Field.FieldType.DATE,
+ ( evaluator == ">" || == ">=")
+ )
+ # Covered x < "20-Oct-2007"
+ $higher :LiteralRestriction(
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ ( evaluator == "<" || == "<="),
+ eval( dateValue.after( $lower.getDateValue() ) )
+ )
+
+ # No "<" or "<=" restrictions between these two
+ not LiteralRestriction(
+ ( evaluator == ">=" || == ">" ),
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ eval( dateValue.after( $lower.getDateValue() ) ),
+ eval( dateValue.before( $higher.getDateValue() ) )
+ )
+ # gap ( x < "10-Oct-2007" ) or ( x > "10-Oct-2007" ) or ( x >= "15-Oct-2007" )
+ $gap :Gap(
+ restriction.fieldId == $lower.fieldId,
+ restriction.patternIsNot == $lower.patternIsNot,
+ eval( restriction.getDateValue().after( $lower.getDateValue() ) ),
+ eval( restriction.getDateValue().before( $higher.getDateValue() ) )
+ )
+ then
+ #System.out.println( $lower + " | " + $higher );
+ retract( $gap );
+ data.remove( $gap );
+end
+/*
+#
+# Example: covered ( x > 10 ), ( x < 100 )and ( x == 50 )
+# reports that ( x < 50 ) ( x > 50 ) is missing.
+#
+rule "Remove useless integer gaps"
+ when
+ # Covered x > 10
+ $lower :LiteralRestriction(
+ valueType == Field.FieldType.INT,
+ ( evaluator == ">" || == ">=")
+ )
+
+ # Covered x < 100
+ $higher :LiteralRestriction(
+ fieldId == $lower.fieldId,
+ intValue > $lower.intValue,
+ patternIsNot == $lower.patternIsNot,
+ ( evaluator == "<" || == "<=")
+ )
+
+ # Nothing in between except "==" restrictions
+ not LiteralRestriction(
+ evaluator != "==",
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ intValue > $lower.intValue,
+ intValue < $higher.intValue
+ )
+
+ # gap ( x < 50.0 ) or ( x > 50.0 )
+ $gap :Gap(
+ restriction.fieldId == $lower.fieldId,
+ restriction.patternIsNot == $lower.patternIsNot,
+ restriction.evaluator == "==",
+ restriction.intValue > $lower.intValue,
+ restriction.intValue < $higher.intValue
+ )
+ then
+ retract( $gap );
+ data.remove( $gap );
+end
+#
+# Example: covered ( x > 10.0 ), ( x < 100.0 )and ( x == 50.0 )
+# reports that ( x < 50.0 ) ( x > 50.0 ) is missing.
+#
+rule "Remove useless double gaps"
+ when
+ # Covered x > 10.0
+ $lower :LiteralRestriction(
+ valueType == Field.FieldType.DOUBLE,
+ ( evaluator == ">" || == ">=")
+ )
+
+ # Covered x < 100.0
+ $higher :LiteralRestriction(
+ fieldId == $lower.fieldId,
+ doubleValue > $lower.doubleValue,
+ patternIsNot == $lower.patternIsNot,
+ ( evaluator == "<" || == "<=")
+ )
+
+ # Nothing in between except "==" restrictions
+ not LiteralRestriction(
+ evaluator != "==",
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ doubleValue > $lower.doubleValue,
+ doubleValue < $higher.doubleValue
+ )
+
+ # gap ( x < 50.0 ) or ( x > 50.0 )
+ $gap :Gap(
+ restriction.fieldId == $lower.fieldId,
+ restriction.patternIsNot == $lower.patternIsNot,
+ restriction.evaluator == "==",
+ restriction.doubleValue > $lower.doubleValue,
+ restriction.doubleValue < $higher.doubleValue
+ )
+ then
+ retract( $gap );
+ data.remove( $gap );
+end
+
+#
+# Example: covered ( x > "01-Oct-2007" ), ( x < "20-Oct-2007" )and ( x == "10-Oct-2007" )
+# reports that ( x < "10-Oct-2007" ) ( x > "10-Oct-2007" ) is missing.
+#
+rule "Remove useless date gaps"
+ when
+ # Covered x > "01-Oct-2007"
+ $lower :LiteralRestriction(
+ valueType == Field.FieldType.DATE,
+ ( evaluator == ">" || == ">=")
+ )
+
+ # Covered x < "20-Oct-2007"
+ $higher :LiteralRestriction(
+ fieldId == $lower.fieldId,
+ dateValue > $lower.dateValue,
+ patternIsNot == $lower.patternIsNot,
+ ( evaluator == "<" || == "<=")
+ )
+
+ # Nothing in between except "==" restrictions
+ not LiteralRestriction(
+ evaluator != "==",
+ fieldId == $lower.fieldId,
+ patternIsNot == $lower.patternIsNot,
+ dateValue > $lower.dateValue,
+ dateValue < $higher.dateValue
+ )
+
+ # gap ( x < "10-Oct-2007" ) or ( x > "10-Oct-2007" )
+ $gap :Gap(
+ restriction.fieldId == $lower.fieldId,
+ restriction.patternIsNot == $lower.patternIsNot,
+ restriction.evaluator == "==",
+ restriction.dateValue > $lower.dateValue,
+ restriction.dateValue < $higher.dateValue
+ )
+
+ then
+ retract( $gap );
+ data.remove( $gap );
+end
+*/
Modified: labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/rangeChecks/Patterns.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/rangeChecks/Patterns.drl 2007-10-06 14:55:00 UTC (rev 15619)
+++ labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/rangeChecks/Patterns.drl 2007-10-06 19:38:52 UTC (rev 15620)
@@ -54,7 +54,7 @@
then
Number number = FindMissingNumber.testForPattern( $list );
if( number != null ){
- MissingNumberPattern mnp = new MissingNumberPattern( $f, "==", number.toString() );
+ MissingNumberPattern mnp = new MissingNumberPattern( $f, "==", $f.getFieldType(), number.toString() );
data.save( mnp );
}
end
@@ -94,7 +94,7 @@
then
Number number = FindMissingNumber.testForPattern( $list );
if( number != null ){
- MissingNumberPattern mnp = new MissingNumberPattern( $f, "!=", number.toString() );
+ MissingNumberPattern mnp = new MissingNumberPattern( $f, "!=", $f.getFieldType(), number.toString() );
data.save( mnp );
}
end
Added: labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/RangeCheckCleanTest.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/RangeCheckCleanTest.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/RangeCheckCleanTest.java 2007-10-06 19:38:52 UTC (rev 15620)
@@ -0,0 +1,836 @@
+package org.drools.analytics;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.drools.StatelessSession;
+import org.drools.StatelessSessionResult;
+import org.drools.analytics.components.AnalyticsComponent;
+import org.drools.analytics.components.Field;
+import org.drools.analytics.components.LiteralRestriction;
+import org.drools.analytics.dao.AnalyticsData;
+import org.drools.analytics.dao.AnalyticsDataFactory;
+import org.drools.analytics.result.Gap;
+import org.drools.base.RuleNameMatchesAgendaFilter;
+
+/**
+ *
+ * @author Toni Rikkola
+ *
+ */
+public class RangeCheckCleanTest extends TestBase {
+
+ public void testUselessIntegerGapsLesser() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("rangeChecks/clean.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Remove useless integer gaps lesser or lesser and equal"));
+
+ Collection<Object> testData = new ArrayList<Object>();
+
+ Field f = new Field();
+ testData.add(f);
+
+ // > 10 covered
+ LiteralRestriction lower = new LiteralRestriction();
+ lower.setRuleName("> 10 covered");
+ lower.setFieldId(f.getId());
+ lower.setEvaluator(">");
+ lower.setValue("10");
+ testData.add(lower);
+
+ // == 50 covered
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setRuleName("== 50 covered");
+ r1.setFieldId(f.getId());
+ r1.setEvaluator("==");
+ r1.setValue("50");
+ testData.add(r1);
+
+ // > 50 gap
+ Gap g1 = new Gap(f, ">", r1);
+ g1.setFiredRuleName("above");
+ testData.add(g1);
+
+ // < 50 gap
+ Gap g2 = new Gap(f, "<", r1);
+ g2.setFiredRuleName("below");
+ testData.add(g2);
+
+ // > 70 covered
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setRuleName("> 70 covered");
+ r2.setFieldId(f.getId());
+ r2.setEvaluator(">");
+ r2.setValue("70");
+ testData.add(r2);
+
+ // <= 70 gap
+ Gap g3 = new Gap(f, "<=", r2);
+ g3.setFiredRuleName("70gap");
+ testData.add(g3);
+
+ // < 100 covered
+ LiteralRestriction higher = new LiteralRestriction();
+ higher.setRuleName("< 100 covered");
+ higher.setFieldId(f.getId());
+ higher.setEvaluator("<");
+ higher.setValue("100");
+ testData.add(higher);
+
+ AnalyticsData data = AnalyticsDataFactory.getAnalyticsData();
+ session.setGlobal("data", data);
+
+ StatelessSessionResult sessionResult = session
+ .executeWithResults(testData);
+
+ Iterator iter = sessionResult.iterateObjects();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Field) {
+ // Do nothing
+ } else if (o instanceof Gap) {
+ rulesThatHadErrors.add(((Gap) o).getFiredRuleName());
+ } else if (o instanceof AnalyticsComponent) {
+ rulesThatHadErrors.add(((AnalyticsComponent) o).getRuleName());
+ }
+ // System.out.println(o);
+ }
+
+ assertTrue(rulesThatHadErrors.remove("> 10 covered"));
+ assertTrue(rulesThatHadErrors.remove("== 50 covered"));
+ assertTrue(rulesThatHadErrors.remove("> 70 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 100 covered"));
+ assertFalse(rulesThatHadErrors.contains("below"));
+ assertFalse(rulesThatHadErrors.contains("above"));
+ assertFalse(rulesThatHadErrors.contains("70gap"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testUselessIntegerGapsGreater() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("rangeChecks/clean.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Remove useless integer gaps greater or greater and equal"));
+
+ Collection<Object> testData = new ArrayList<Object>();
+
+ Field f = new Field();
+ testData.add(f);
+
+ // > 10 covered
+ LiteralRestriction lower = new LiteralRestriction();
+ lower.setRuleName("> 10 covered");
+ lower.setFieldId(f.getId());
+ lower.setEvaluator(">");
+ lower.setValue("10");
+ testData.add(lower);
+
+ // == 50 covered
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setRuleName("== 50 covered");
+ r1.setFieldId(f.getId());
+ r1.setEvaluator("==");
+ r1.setValue("50");
+ testData.add(r1);
+
+ // > 50 gap
+ Gap g1 = new Gap(f, ">", r1);
+ g1.setFiredRuleName("above");
+ testData.add(g1);
+
+ // < 50 gap
+ Gap g2 = new Gap(f, "<", r1);
+ g2.setFiredRuleName("below");
+ testData.add(g2);
+
+ // < 70 covered
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setRuleName("< 70 covered");
+ r2.setFieldId(f.getId());
+ r2.setEvaluator("<");
+ r2.setValue("70");
+ testData.add(r2);
+
+ // >= 70 gap
+ Gap g3 = new Gap(f, ">=", r2);
+ g3.setFiredRuleName("70gap");
+ testData.add(g3);
+
+ // < 100 covered
+ LiteralRestriction higher = new LiteralRestriction();
+ higher.setRuleName("< 100 covered");
+ higher.setFieldId(f.getId());
+ higher.setEvaluator("<");
+ higher.setValue("100");
+ testData.add(higher);
+
+ AnalyticsData data = AnalyticsDataFactory.getAnalyticsData();
+ session.setGlobal("data", data);
+
+ StatelessSessionResult sessionResult = session
+ .executeWithResults(testData);
+
+ Iterator iter = sessionResult.iterateObjects();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Field) {
+ // Do nothing
+ } else if (o instanceof Gap) {
+ rulesThatHadErrors.add(((Gap) o).getFiredRuleName());
+ } else if (o instanceof AnalyticsComponent) {
+ rulesThatHadErrors.add(((AnalyticsComponent) o).getRuleName());
+ }
+ // System.out.println(o);
+ }
+
+ assertTrue(rulesThatHadErrors.remove("> 10 covered"));
+ assertTrue(rulesThatHadErrors.remove("== 50 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 70 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 100 covered"));
+ assertFalse(rulesThatHadErrors.contains("below"));
+ assertFalse(rulesThatHadErrors.contains("above"));
+ assertFalse(rulesThatHadErrors.contains("70gap"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testUselessDoubleGapsLesser() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("rangeChecks/clean.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Remove useless double gaps lesser or lesser and equal"));
+
+ Collection<Object> testData = new ArrayList<Object>();
+
+ Field f = new Field();
+ testData.add(f);
+
+ // > 10.0 covered
+ LiteralRestriction lower = new LiteralRestriction();
+ lower.setRuleName("> 10.0 covered");
+ lower.setFieldId(f.getId());
+ lower.setEvaluator(">");
+ lower.setValue("10.0");
+ testData.add(lower);
+
+ // == 50.0 covered
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setRuleName("== 50.0 covered");
+ r1.setFieldId(f.getId());
+ r1.setEvaluator("==");
+ r1.setValue("50.0");
+ testData.add(r1);
+
+ // > 50.0 gap
+ Gap g1 = new Gap(f, ">", r1);
+ g1.setFiredRuleName("above");
+ testData.add(g1);
+
+ // < 50.0 gap
+ Gap g2 = new Gap(f, "<", r1);
+ g2.setFiredRuleName("below");
+ testData.add(g2);
+
+ // > 70.0 covered
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setRuleName("> 70.0 covered");
+ r2.setFieldId(f.getId());
+ r2.setEvaluator(">");
+ r2.setValue("70.0");
+ testData.add(r2);
+
+ // <= 70.0 gap
+ Gap g3 = new Gap(f, "<=", r2);
+ g3.setFiredRuleName("70gap");
+ testData.add(g3);
+
+ // < 100.0 covered
+ LiteralRestriction higher = new LiteralRestriction();
+ higher.setRuleName("< 100.0 covered");
+ higher.setFieldId(f.getId());
+ higher.setEvaluator("<");
+ higher.setValue("100.0");
+ testData.add(higher);
+
+ AnalyticsData data = AnalyticsDataFactory.getAnalyticsData();
+ session.setGlobal("data", data);
+
+ StatelessSessionResult sessionResult = session
+ .executeWithResults(testData);
+
+ Iterator iter = sessionResult.iterateObjects();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Field) {
+ // Do nothing
+ } else if (o instanceof Gap) {
+ rulesThatHadErrors.add(((Gap) o).getFiredRuleName());
+ } else if (o instanceof AnalyticsComponent) {
+ rulesThatHadErrors.add(((AnalyticsComponent) o).getRuleName());
+ }
+ // System.out.println(o);
+ }
+
+ assertTrue(rulesThatHadErrors.remove("> 10.0 covered"));
+ assertTrue(rulesThatHadErrors.remove("== 50.0 covered"));
+ assertTrue(rulesThatHadErrors.remove("> 70.0 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 100.0 covered"));
+ assertFalse(rulesThatHadErrors.contains("below"));
+ assertFalse(rulesThatHadErrors.contains("above"));
+ assertFalse(rulesThatHadErrors.contains("70gap"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testUselessDoubleGapsGreater() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("rangeChecks/clean.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Remove useless double gaps greater or greater and equal"));
+
+ Collection<Object> testData = new ArrayList<Object>();
+
+ Field f = new Field();
+ testData.add(f);
+
+ // > 10.0 covered
+ LiteralRestriction lower = new LiteralRestriction();
+ lower.setRuleName("> 10.0 covered");
+ lower.setFieldId(f.getId());
+ lower.setEvaluator(">");
+ lower.setValue("10.0");
+ testData.add(lower);
+
+ // == 50.0 covered
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setRuleName("== 50.0 covered");
+ r1.setFieldId(f.getId());
+ r1.setEvaluator("==");
+ r1.setValue("50.0");
+ testData.add(r1);
+
+ // > 50.0 gap
+ Gap g1 = new Gap(f, ">", r1);
+ g1.setFiredRuleName("above");
+ testData.add(g1);
+
+ // < 50.0 gap
+ Gap g2 = new Gap(f, "<", r1);
+ g2.setFiredRuleName("below");
+ testData.add(g2);
+
+ // < 70.0 covered
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setRuleName("< 70.0 covered");
+ r2.setFieldId(f.getId());
+ r2.setEvaluator("<");
+ r2.setValue("70.0");
+ testData.add(r2);
+
+ // >= 70.0 gap
+ Gap g3 = new Gap(f, ">=", r2);
+ g3.setFiredRuleName("70gap");
+ testData.add(g3);
+
+ // < 100.0 covered
+ LiteralRestriction higher = new LiteralRestriction();
+ higher.setRuleName("< 100.0 covered");
+ higher.setFieldId(f.getId());
+ higher.setEvaluator("<");
+ higher.setValue("100.0");
+ testData.add(higher);
+
+ AnalyticsData data = AnalyticsDataFactory.getAnalyticsData();
+ session.setGlobal("data", data);
+
+ StatelessSessionResult sessionResult = session
+ .executeWithResults(testData);
+
+ Iterator iter = sessionResult.iterateObjects();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Field) {
+ // Do nothing
+ } else if (o instanceof Gap) {
+ rulesThatHadErrors.add(((Gap) o).getFiredRuleName());
+ } else if (o instanceof AnalyticsComponent) {
+ rulesThatHadErrors.add(((AnalyticsComponent) o).getRuleName());
+ }
+ // System.out.println(o);
+ }
+
+ assertTrue(rulesThatHadErrors.remove("> 10.0 covered"));
+ assertTrue(rulesThatHadErrors.remove("== 50.0 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 70.0 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 100.0 covered"));
+ assertFalse(rulesThatHadErrors.contains("below"));
+ assertFalse(rulesThatHadErrors.contains("above"));
+ assertFalse(rulesThatHadErrors.contains("70gap"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testUselessDateGapsLesser() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("rangeChecks/clean.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Remove useless date gaps lesser or lesser and equal"));
+
+ Collection<Object> testData = new ArrayList<Object>();
+
+ Field f = new Field();
+ testData.add(f);
+
+ // > "01-Oct-2007" covered
+ LiteralRestriction lower = new LiteralRestriction();
+ lower.setRuleName("> 01-Oct-2007 covered");
+ lower.setFieldId(f.getId());
+ lower.setEvaluator(">");
+ lower.setValue("01-Oct-2007");
+ testData.add(lower);
+
+ // == "10-Oct-2007" covered
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setRuleName("== 10-Oct-2007 covered");
+ r1.setFieldId(f.getId());
+ r1.setEvaluator("==");
+ r1.setValue("10-Oct-2007");
+ testData.add(r1);
+
+ // > "10-Oct-2007" gap
+ Gap g1 = new Gap(f, ">", r1);
+ g1.setFiredRuleName("above");
+ testData.add(g1);
+
+ // < "10-Oct-2007" gap
+ Gap g2 = new Gap(f, "<", r1);
+ g2.setFiredRuleName("below");
+ testData.add(g2);
+
+ // > "15-Oct-2007" covered
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setRuleName("> 15-Oct-2007 covered");
+ r2.setFieldId(f.getId());
+ r2.setEvaluator(">");
+ r2.setValue("15-Oct-2007");
+ testData.add(r2);
+
+ // <= "15-Oct-2007" gap
+ Gap g3 = new Gap(f, "<=", r2);
+ g3.setFiredRuleName("15-Oct-2007gap");
+ testData.add(g3);
+
+ // < "20-Oct-2007" covered
+ LiteralRestriction higher = new LiteralRestriction();
+ higher.setRuleName("< 20-Oct-2007 covered");
+ higher.setFieldId(f.getId());
+ higher.setEvaluator("<");
+ higher.setValue("20-Oct-2007");
+ testData.add(higher);
+
+ AnalyticsData data = AnalyticsDataFactory.getAnalyticsData();
+ session.setGlobal("data", data);
+
+ StatelessSessionResult sessionResult = session
+ .executeWithResults(testData);
+
+ Iterator iter = sessionResult.iterateObjects();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Field) {
+ // Do nothing
+ } else if (o instanceof Gap) {
+ rulesThatHadErrors.add(((Gap) o).getFiredRuleName());
+ } else if (o instanceof AnalyticsComponent) {
+ rulesThatHadErrors.add(((AnalyticsComponent) o).getRuleName());
+ }
+ // System.out.println(o);
+ }
+
+ assertTrue(rulesThatHadErrors.remove("> 01-Oct-2007 covered"));
+ assertTrue(rulesThatHadErrors.remove("== 10-Oct-2007 covered"));
+ assertTrue(rulesThatHadErrors.remove("> 15-Oct-2007 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 20-Oct-2007 covered"));
+ assertFalse(rulesThatHadErrors.contains("below"));
+ assertFalse(rulesThatHadErrors.contains("above"));
+ assertFalse(rulesThatHadErrors.contains("15-Oct-2007gap"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testUselessDateGapsGreater() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("rangeChecks/clean.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Remove useless date gaps greater or greater and equal"));
+
+ Collection<Object> testData = new ArrayList<Object>();
+
+ Field f = new Field();
+ testData.add(f);
+
+ // > "01-Oct-2007" covered
+ LiteralRestriction lower = new LiteralRestriction();
+ lower.setRuleName("> 01-Oct-2007 covered");
+ lower.setFieldId(f.getId());
+ lower.setEvaluator(">");
+ lower.setValue("01-Oct-2007");
+ testData.add(lower);
+
+ // == "10-Oct-2007" covered
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setRuleName("== 10-Oct-2007 covered");
+ r1.setFieldId(f.getId());
+ r1.setEvaluator("==");
+ r1.setValue("10-Oct-2007");
+ testData.add(r1);
+
+ // > "10-Oct-2007" gap
+ Gap g1 = new Gap(f, ">", r1);
+ g1.setFiredRuleName("above");
+ testData.add(g1);
+
+ // < "10-Oct-2007" gap
+ Gap g2 = new Gap(f, "<", r1);
+ g2.setFiredRuleName("below");
+ testData.add(g2);
+
+ // < "15-Oct-2007" covered
+ LiteralRestriction r2 = new LiteralRestriction();
+ r2.setRuleName("< 15-Oct-2007 covered");
+ r2.setFieldId(f.getId());
+ r2.setEvaluator("<");
+ r2.setValue("15-Oct-2007");
+ testData.add(r2);
+
+ // >= "15-Oct-2007" gap
+ Gap g3 = new Gap(f, ">=", r2);
+ g3.setFiredRuleName("15-Oct-2007gap");
+ testData.add(g3);
+
+ // < "20-Oct-2007" covered
+ LiteralRestriction higher = new LiteralRestriction();
+ higher.setRuleName("< 20-Oct-2007 covered");
+ higher.setFieldId(f.getId());
+ higher.setEvaluator("<");
+ higher.setValue("20-Oct-2007");
+ testData.add(higher);
+
+ AnalyticsData data = AnalyticsDataFactory.getAnalyticsData();
+ session.setGlobal("data", data);
+
+ StatelessSessionResult sessionResult = session
+ .executeWithResults(testData);
+
+ Iterator iter = sessionResult.iterateObjects();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Field) {
+ // Do nothing
+ } else if (o instanceof Gap) {
+ rulesThatHadErrors.add(((Gap) o).getFiredRuleName());
+ } else if (o instanceof AnalyticsComponent) {
+ rulesThatHadErrors.add(((AnalyticsComponent) o).getRuleName());
+ }
+ // System.out.println(o);
+ }
+
+ assertTrue(rulesThatHadErrors.remove("> 01-Oct-2007 covered"));
+ assertTrue(rulesThatHadErrors.remove("== 10-Oct-2007 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 15-Oct-2007 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 20-Oct-2007 covered"));
+ assertFalse(rulesThatHadErrors.contains("below"));
+ assertFalse(rulesThatHadErrors.contains("above"));
+ assertFalse(rulesThatHadErrors.contains("15-Oct-2007gap"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+/*
+ public void testUselessIntegerGapAboveRestriction1() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("rangeChecks/clean.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Remove useless integer gaps"));
+
+ Collection<Object> testData = new ArrayList<Object>();
+
+ Field f = new Field();
+ testData.add(f);
+
+ // > 10 covered
+ LiteralRestriction lower = new LiteralRestriction();
+ lower.setRuleName("> 10 covered");
+ lower.setFieldId(f.getId());
+ lower.setEvaluator(">");
+ lower.setValue("10");
+ testData.add(lower);
+
+ // == 50 covered
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setRuleName("== 50 covered");
+ r1.setFieldId(f.getId());
+ r1.setEvaluator("==");
+ r1.setValue("50");
+ testData.add(r1);
+
+ // > 50 gap
+ Gap g1 = new Gap(f, ">", r1);
+ g1.setFiredRuleName("above");
+ testData.add(g1);
+
+ // < 50 gap
+ Gap g2 = new Gap(f, "<", r1);
+ g2.setFiredRuleName("below");
+ testData.add(g2);
+
+ // < 100 covered
+ LiteralRestriction higher = new LiteralRestriction();
+ higher.setRuleName("< 100 covered");
+ higher.setFieldId(f.getId());
+ higher.setEvaluator("<");
+ higher.setValue("100");
+ testData.add(higher);
+
+ AnalyticsData data = AnalyticsDataFactory.getAnalyticsData();
+ session.setGlobal("data", data);
+
+ StatelessSessionResult sessionResult = session
+ .executeWithResults(testData);
+
+ Iterator iter = sessionResult.iterateObjects();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Field) {
+ // Do nothing
+ } else if (o instanceof Gap) {
+ rulesThatHadErrors.add(((Gap) o).getFiredRuleName());
+ } else if (o instanceof AnalyticsComponent) {
+ rulesThatHadErrors.add(((AnalyticsComponent) o).getRuleName());
+ }
+ // System.out.println(o);
+ }
+
+ assertTrue(rulesThatHadErrors.remove("> 10 covered"));
+ assertTrue(rulesThatHadErrors.remove("== 50 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 100 covered"));
+ assertFalse(rulesThatHadErrors.contains("below"));
+ assertFalse(rulesThatHadErrors.contains("above"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testUselessDoubleGapAboveRestriction() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("rangeChecks/clean.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Remove useless double gaps"));
+
+ Collection<Object> testData = new ArrayList<Object>();
+
+ Field f = new Field();
+ testData.add(f);
+
+ // > 10 covered
+ LiteralRestriction lower = new LiteralRestriction();
+ lower.setRuleName("> 10.0 covered");
+ lower.setFieldId(f.getId());
+ lower.setEvaluator(">");
+ lower.setValue("10.0");
+ testData.add(lower);
+
+ // == 50 covered
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setRuleName("== 50.0 covered");
+ r1.setFieldId(f.getId());
+ r1.setEvaluator("==");
+ r1.setValue("50.0");
+ testData.add(r1);
+
+ // > 50 gap
+ Gap g1 = new Gap(f, ">", r1);
+ g1.setFiredRuleName("above");
+ testData.add(g1);
+
+ // < 50 gap
+ Gap g2 = new Gap(f, "<", r1);
+ g2.setFiredRuleName("below");
+ testData.add(g2);
+
+ // < 100 covered
+ LiteralRestriction higher = new LiteralRestriction();
+ higher.setRuleName("< 100.0 covered");
+ higher.setFieldId(f.getId());
+ higher.setEvaluator("<");
+ higher.setValue("100.0");
+ testData.add(higher);
+
+ AnalyticsData data = AnalyticsDataFactory.getAnalyticsData();
+ session.setGlobal("data", data);
+
+ StatelessSessionResult sessionResult = session
+ .executeWithResults(testData);
+
+ Iterator iter = sessionResult.iterateObjects();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Field) {
+ // Do nothing
+ } else if (o instanceof Gap) {
+ rulesThatHadErrors.add(((Gap) o).getFiredRuleName());
+ } else if (o instanceof AnalyticsComponent) {
+ rulesThatHadErrors.add(((AnalyticsComponent) o).getRuleName());
+ }
+ // System.out.println(o);
+ }
+
+ assertTrue(rulesThatHadErrors.remove("> 10.0 covered"));
+ assertTrue(rulesThatHadErrors.remove("== 50.0 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 100.0 covered"));
+ assertFalse(rulesThatHadErrors.contains("below"));
+ assertFalse(rulesThatHadErrors.contains("above"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+
+ public void testUselessDateGapBelowRestriction() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("rangeChecks/clean.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Remove useless date gaps"));
+
+ Collection<Object> testData = new ArrayList<Object>();
+
+ Field f = new Field();
+ testData.add(f);
+
+ // > 01-Oct-2007 covered
+ LiteralRestriction lower = new LiteralRestriction();
+ lower.setRuleName("> 01-Oct-2007 covered");
+ lower.setFieldId(f.getId());
+ lower.setEvaluator(">");
+ lower.setValue("01-Oct-2007");
+ testData.add(lower);
+
+ // == 10-Oct-2007 covered
+ LiteralRestriction r1 = new LiteralRestriction();
+ r1.setRuleName("== 10-Oct-2007 covered");
+ r1.setFieldId(f.getId());
+ r1.setEvaluator("==");
+ r1.setValue("10-Oct-2007");
+ testData.add(r1);
+
+ // > 10-Oct-2007 gap
+ Gap g1 = new Gap(f, ">", r1);
+ g1.setFiredRuleName("above");
+ testData.add(g1);
+
+ // < 10-Oct-2007 gap
+ Gap g2 = new Gap(f, "<", r1);
+ g2.setFiredRuleName("below");
+ testData.add(g2);
+
+ // < 20-Oct-2007 covered
+ LiteralRestriction higher = new LiteralRestriction();
+ higher.setRuleName("< 20-Oct-2007 covered");
+ higher.setFieldId(f.getId());
+ higher.setEvaluator("<");
+ higher.setValue("20-Oct-2007");
+ testData.add(higher);
+
+ AnalyticsData data = AnalyticsDataFactory.getAnalyticsData();
+ session.setGlobal("data", data);
+
+ StatelessSessionResult sessionResult = session
+ .executeWithResults(testData);
+
+ Iterator iter = sessionResult.iterateObjects();
+
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Field) {
+ // Do nothing
+ } else if (o instanceof Gap) {
+ rulesThatHadErrors.add(((Gap) o).getFiredRuleName());
+ } else if (o instanceof AnalyticsComponent) {
+ rulesThatHadErrors.add(((AnalyticsComponent) o).getRuleName());
+ } //
+ // System.out.println(o);
+ }
+
+ assertTrue(rulesThatHadErrors.remove("> 01-Oct-2007 covered"));
+ assertTrue(rulesThatHadErrors.remove("== 10-Oct-2007 covered"));
+ assertTrue(rulesThatHadErrors.remove("< 20-Oct-2007 covered"));
+ assertFalse(rulesThatHadErrors.contains("above"));
+ assertFalse(rulesThatHadErrors.contains("below"));
+
+ if (!rulesThatHadErrors.isEmpty()) {
+ for (String string : rulesThatHadErrors) {
+ fail("Rule " + string + " caused an error.");
+ }
+ }
+ }
+ */
+}
More information about the jboss-svn-commits
mailing list