[jboss-svn-commits] JBL Code SVN: r32447 - in labs/jbossrules/trunk/drools-verifier/src: main/java/org/drools/verifier/misc and 21 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Tue Apr 6 09:17:12 EDT 2010
Author: Rikkola
Date: 2010-04-06 09:17:08 -0400 (Tue, 06 Apr 2010)
New Revision: 32447
Added:
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/BooleanRestriction.java
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/DateRestriction.java
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/NumberRestriction.java
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/StringRestriction.java
Modified:
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/Field.java
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/LiteralRestriction.java
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/misc/FindMissingNumber.java
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/components/Gap.java
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/components/MissingRange.java
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/html/MissingRangesReportVisitor.java
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/visitor/FieldConstraintDescrVisitor.java
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incoherence/Patterns.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incoherence/Restrictions.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incompatibility/Restrictions.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/missingEquality/MissingEquality.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/opposites/Restrictions.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/overlaps/Restrictions.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Clean.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Dates.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Doubles.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Integers.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/NumberPatterns.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/scope-knowledge-package.xml
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/subsumption/Restrictions.drl
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/SolversTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/alwaysFalse/AlwaysFalseTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/alwaysTrue/AlwaysTruePatternTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/components/LiteralRestrictionTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/data/VerifierDataMapsTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incompatibility/IncompatibilityPatternsTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incompatibility/IncompatibilityRestrictionsTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/opposites/OppositePatternsTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/opposites/OppositeRestrictionsTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/overlaps/OverlappingRestrictionsTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/redundancy/NotesTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/solver/PatternSolverTest.java
Log:
JBRULES-2473 : Split LiteralRestriction to Boolean-, String-, Date-, and NumberRestriction
Added: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/BooleanRestriction.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/BooleanRestriction.java (rev 0)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/BooleanRestriction.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -0,0 +1,34 @@
+package org.drools.verifier.components;
+
+/**
+ *
+ * @author trikkola
+ *
+ */
+public class BooleanRestriction extends LiteralRestriction {
+
+ private Boolean value;
+
+ public BooleanRestriction(Pattern pattern) {
+ super( pattern );
+ }
+
+ public void setValue(Boolean value) {
+ this.value = value;
+ }
+
+ public boolean getValue() {
+ return value;
+ }
+
+ @Override
+ public String getValueAsString() {
+ return value.toString();
+ }
+
+ @Override
+ public String getValueType() {
+ return value.getClass().getName();
+ }
+
+}
Added: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/DateRestriction.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/DateRestriction.java (rev 0)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/DateRestriction.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -0,0 +1,36 @@
+package org.drools.verifier.components;
+
+import java.text.DateFormat;
+import java.util.Date;
+
+/**
+ *
+ * @author trikkola
+ *
+ */
+public class DateRestriction extends LiteralRestriction {
+
+ private Date value;
+
+ public DateRestriction(Pattern pattern) {
+ super( pattern );
+ }
+
+ public void setValue(Date value) {
+ this.value = value;
+ }
+
+ public Date getValue() {
+ return value;
+ }
+
+ @Override
+ public String getValueAsString() {
+ return value.toString();
+ }
+
+ @Override
+ public String getValueType() {
+ return value.getClass().getName();
+ }
+}
Modified: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/Field.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/Field.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/Field.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -11,10 +11,10 @@
implements
Cause {
- public static final String BOOLEAN = "boolean";
+ public static final String BOOLEAN = "java.lang.Boolean";
public static final String STRING = "java.lang.String";
- public static final String INT = "int";
- public static final String DOUBLE = "double";
+ public static final String INT = "java.lang.Integer";
+ public static final String DOUBLE = "java.lang.Double";
public static final String DATE = "java.util.Date";
public static final String VARIABLE = "Variable";
public static final String OBJECT = "Object";
Modified: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/LiteralRestriction.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/LiteralRestriction.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/LiteralRestriction.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -1,9 +1,7 @@
package org.drools.verifier.components;
import java.text.SimpleDateFormat;
-import java.util.Date;
import java.util.Locale;
-import java.util.zip.DataFormatException;
import org.drools.verifier.report.components.Cause;
@@ -11,22 +9,10 @@
*
* @author Toni Rikkola
*/
-public class LiteralRestriction extends Restriction
+public abstract class LiteralRestriction extends Restriction
implements
Cause {
- private String valueType;
-
- private boolean booleanValue;
-
- private int intValue;
-
- private double doubleValue;
-
- private String stringValue;
-
- private Date dateValue;
-
public LiteralRestriction(Pattern pattern) {
super( pattern );
}
@@ -35,120 +21,36 @@
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().equals( valueType ) ) {
- throw new DataFormatException( "Value types did not match. Value type " + restriction.getValueType() + " was compared to " + valueType );
- }
+ public abstract String getValueAsString();
- if ( Field.DATE.equals( valueType ) ) {
- return dateValue.compareTo( restriction.getDateValue() );
- } else if ( Field.DOUBLE.equals( valueType ) ) {
- if ( doubleValue > restriction.getDoubleValue() ) {
- return 1;
- } else if ( doubleValue < restriction.getDoubleValue() ) {
- return -1;
- } else {
- return 0;
- }
- } else if ( Field.INT.equals( valueType ) ) {
- if ( intValue > restriction.getIntValue() ) {
- return 1;
- } else if ( intValue < restriction.getIntValue() ) {
- return -1;
- } else {
- return 0;
- }
- } else if ( Field.BOOLEAN.equals( valueType ) ) {
- if ( booleanValue == restriction.getBooleanValue() ) {
- return 0;
- } else {
- return 1;
- }
- } else if ( Field.STRING.equals( valueType ) ) {
- return stringValue.compareTo( restriction.getValueAsString() );
- } else if ( Field.UNKNOWN.equals( valueType ) ) {
- return 0;
- }
+ public abstract String getValueType();
- throw new DataFormatException( "Value types did not match. Value type " + restriction.getValueType() + " was compared to " + valueType );
- }
+ public static LiteralRestriction createRestriction(Pattern pattern,
+ String value) {
- public Object getValueAsObject() {
- if ( valueType == Field.BOOLEAN ) {
- return Boolean.valueOf( booleanValue );
- } else if ( valueType == Field.DATE ) {
- return dateValue;
- } else if ( valueType == Field.DOUBLE ) {
- return Double.valueOf( doubleValue );
- } else if ( valueType == Field.INT ) {
- return Integer.valueOf( intValue );
- }
- return stringValue;
- }
-
- public String getValueAsString() {
- return stringValue;
- }
-
- public double getDoubleValue() {
- return doubleValue;
- }
-
- public int getIntValue() {
- return intValue;
- }
-
- public String getValueType() {
- return valueType;
- }
-
- public Date getDateValue() {
- return dateValue;
- }
-
- public void setValue(String value) {
-
if ( value == null ) {
- stringValue = null;
- valueType = Field.UNKNOWN;
- return;
+ return new StringRestriction( pattern );
}
- stringValue = value;
- valueType = Field.STRING;
-
if ( "true".equals( value ) || "false".equals( value ) ) {
- booleanValue = value.equals( "true" );
- valueType = Field.BOOLEAN;
- stringValue = value;
+ BooleanRestriction booleanRestriction = new BooleanRestriction( pattern );
+ booleanRestriction.setValue( value.equals( "true" ) );
+
+ return booleanRestriction;
}
try {
- intValue = Integer.parseInt( value );
- valueType = Field.INT;
- stringValue = value;
- //even when value is an int, we fill doubleValue too
- doubleValue = intValue;
- return;
+ NumberRestriction numberRestriction = new NumberRestriction( pattern );
+ numberRestriction.setValue( Integer.parseInt( value ) );
+ return numberRestriction;
} catch ( NumberFormatException e ) {
// Not int.
}
try {
- doubleValue = Double.parseDouble( value );
- valueType = Field.DOUBLE;
- stringValue = value;
- return;
+ NumberRestriction numberRestriction = new NumberRestriction( pattern );
+ numberRestriction.setValue( Double.parseDouble( value ) );
+ return numberRestriction;
} catch ( NumberFormatException e ) {
// Not double.
}
@@ -160,27 +62,22 @@
fmt = "dd-MMM-yyyy";
}
- dateValue = new SimpleDateFormat( fmt,
- Locale.ENGLISH ).parse( value );
- valueType = Field.DATE;
- stringValue = value;
- return;
+ DateRestriction dateRestriction = new DateRestriction( pattern );
+ dateRestriction.setValue( new SimpleDateFormat( fmt,
+ Locale.ENGLISH ).parse( value ) );
+
+ return dateRestriction;
} catch ( Exception e ) {
// Not a date.
}
+ StringRestriction stringRestriction = new StringRestriction( pattern );
+ stringRestriction.setValue( value );
+ return stringRestriction;
}
- public boolean getBooleanValue() {
- return booleanValue;
- }
-
- public void setBooleanValue(boolean booleanValue) {
- this.booleanValue = booleanValue;
- }
-
@Override
public String toString() {
- return "LiteralRestriction from rule [" + getRuleName() + "] value '" + operator.getOperatorString() + " " + stringValue + "'";
+ return "LiteralRestriction from rule [" + getRuleName() + "] value '" + operator.getOperatorString() + " " + getValueAsString() + "'";
}
}
Added: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/NumberRestriction.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/NumberRestriction.java (rev 0)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/NumberRestriction.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -0,0 +1,37 @@
+package org.drools.verifier.components;
+
+/**
+ *
+ * @author trikkola
+ *
+ */
+public class NumberRestriction extends LiteralRestriction {
+
+ private Number value;
+
+ public NumberRestriction(Pattern pattern) {
+ super( pattern );
+ }
+
+ public void setValue(Number number) {
+ this.value = number;;
+ }
+
+ public boolean isInt() {
+ return value instanceof Integer;
+ }
+
+ public Number getValue() {
+ return value;
+ }
+
+ @Override
+ public String getValueAsString() {
+ return value.toString();
+ }
+
+ @Override
+ public String getValueType() {
+ return value.getClass().getName();
+ }
+}
Added: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/StringRestriction.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/StringRestriction.java (rev 0)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/components/StringRestriction.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -0,0 +1,41 @@
+package org.drools.verifier.components;
+
+/**
+ *
+ * @author trikkola
+ *
+ */
+public class StringRestriction extends LiteralRestriction {
+
+ private String value;
+
+ public StringRestriction(Pattern pattern) {
+ super(pattern);
+ }
+
+ public void setValue(String value) {
+ this.value = value;
+ }
+
+ public String getValue() {
+ return value;
+ }
+
+ @Override
+ public String getValueAsString() {
+ if (value == null) {
+ return "";
+ } else {
+ return value;
+ }
+ }
+
+ @Override
+ public String getValueType() {
+ if (value == null) {
+ return Field.UNKNOWN;
+ } else {
+ return value.getClass().getName();
+ }
+ }
+}
Modified: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/misc/FindMissingNumber.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/misc/FindMissingNumber.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/misc/FindMissingNumber.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -4,8 +4,7 @@
import java.util.Arrays;
import java.util.Collection;
-import org.drools.verifier.components.Field;
-import org.drools.verifier.components.LiteralRestriction;
+import org.drools.verifier.components.NumberRestriction;
public class FindMissingNumber {
@@ -18,7 +17,7 @@
* @return false if can't find a pattern or constraints list is null or size
* of the list is under 3.
*/
- public static Number testForPattern(Collection<LiteralRestriction> restrictions) {
+ public static Number testForPattern(Collection<NumberRestriction> restrictions) {
if ( restrictions == null || restrictions.size() < MIN_NUMBER_OF_RESTRICTIONS ) {
return null;
@@ -27,11 +26,11 @@
BigDecimal[] numbers = new BigDecimal[restrictions.size()];
int index = 0;
- for ( LiteralRestriction restriction : restrictions ) {
- if ( restriction.getValueType() == Field.DOUBLE ) {
- numbers[index++] = BigDecimal.valueOf( restriction.getDoubleValue() );
- } else if ( restriction.getValueType() == Field.INT ) {
- numbers[index++] = BigDecimal.valueOf( restriction.getIntValue() );
+ for ( NumberRestriction restriction : restrictions ) {
+ if ( restriction.isInt() ) {
+ numbers[index++] = BigDecimal.valueOf( restriction.getValue().intValue() );
+ } else {
+ numbers[index++] = BigDecimal.valueOf( restriction.getValue().doubleValue() );
}
}
Modified: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/components/Gap.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/components/Gap.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/components/Gap.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -50,10 +50,6 @@
return restriction.getValueAsString();
}
- public Object getValueAsObject() {
- return restriction.getValueAsObject();
- }
-
@Override
public String toString() {
return "Gap: (" + field + ") " + getOperator() + " " + getValueAsString() + " from rule: [" + getRuleName() + "]";
Modified: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/components/MissingRange.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/components/MissingRange.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/components/MissingRange.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -65,8 +65,6 @@
return operator;
}
- public abstract Object getValueAsObject();
-
public abstract String getValueAsString();
}
Modified: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/html/MissingRangesReportVisitor.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/html/MissingRangesReportVisitor.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/report/html/MissingRangesReportVisitor.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -8,7 +8,7 @@
import org.drools.base.evaluators.Operator;
import org.drools.verifier.components.Field;
-import org.drools.verifier.components.LiteralRestriction;
+import org.drools.verifier.components.NumberRestriction;
import org.drools.verifier.components.Restriction;
import org.drools.verifier.components.VerifierComponentType;
import org.drools.verifier.data.VerifierData;
@@ -28,7 +28,7 @@
Collection<String> stringRows = new ArrayList<String>();
for ( MissingRange cause : causes ) {
- dt.put( cause.getValueAsObject(),
+ dt.put( cause.getValueAsString(),
new DataRow( null,
null,
cause.getOperator(),
@@ -36,11 +36,11 @@
}
for ( Restriction r : restrictions ) {
- if ( r instanceof LiteralRestriction ) {
+ if ( r instanceof NumberRestriction ) {
try {
- LiteralRestriction restriction = (LiteralRestriction) r;
+ NumberRestriction restriction = (NumberRestriction) r;
- dt.put( restriction.getValueAsObject(),
+ dt.put( restriction.getValue(),
new DataRow( restriction.getRulePath(),
restriction.getRuleName(),
restriction.getOperator(),
Modified: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/visitor/FieldConstraintDescrVisitor.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/visitor/FieldConstraintDescrVisitor.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/visitor/FieldConstraintDescrVisitor.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -128,14 +128,14 @@
*/
private void visit(LiteralRestrictionDescr descr) {
- LiteralRestriction restriction = new LiteralRestriction( pattern );
+ LiteralRestriction restriction = LiteralRestriction.createRestriction( pattern,
+ descr.getText() );
restriction.setPatternIsNot( pattern.isPatternNot() );
restriction.setConstraintPath( constraint.getPath() );
restriction.setFieldPath( constraint.getFieldPath() );
restriction.setOperator( Operator.determineOperator( descr.getEvaluator(),
descr.isNegated() ) );
- restriction.setValue( descr.getText() );
restriction.setOrderNumber( orderNumber );
restriction.setParentPath( pattern.getPath() );
restriction.setParentType( pattern.getVerifierComponentType() );
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incoherence/Patterns.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incoherence/Patterns.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incoherence/Patterns.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -4,6 +4,7 @@
#list any import classes here.
import org.drools.verifier.components.VerifierRule;
import org.drools.verifier.components.LiteralRestriction;
+import org.drools.verifier.components.NumberRestriction;
import org.drools.verifier.components.SubPattern;
import org.drools.verifier.components.SubRule;
import org.drools.verifier.components.Pattern;
@@ -47,11 +48,10 @@
restrictionType == $r1.restrictionType,
fieldPath == $r1.fieldPath,
valueType == $r1.valueType,
- operator == $r1.operator
+ operator == $r1.operator,
+ valueAsString == $r1.valueAsString
)
- eval( $r1.compareValues( $r2 ) == 0 )
-
$pp1 :SubPattern(
patternPath == $r1.patternPath
)
@@ -177,20 +177,19 @@
#
rule "Incoherent Patterns in rule possibility, ranges when not conflicts with lesser value"
when
- $r1 :LiteralRestriction(
+ $r1 :NumberRestriction(
patternIsNot == true,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL )
)
- $r2 :LiteralRestriction(
+ $r2 :NumberRestriction(
rulePath == $r1.rulePath,
patternIsNot == false,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL || == Operator.EQUAL ),
- fieldPath == $r1.fieldPath
+ fieldPath == $r1.fieldPath,
+ value > $r1.value
)
- eval( $r1.compareValues( $r2 ) == -1 )
-
$pp1 :SubPattern(
patternPath == $r1.patternPath
)
@@ -246,20 +245,19 @@
#
rule "Incoherent Patterns in rule possibility, ranges when not conflicts with greater value"
when
- $r1 :LiteralRestriction(
+ $r1 :NumberRestriction(
patternIsNot == true,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL )
)
- $r2 :LiteralRestriction(
+ $r2 :NumberRestriction(
rulePath == $r1.rulePath,
patternIsNot == false,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL || == Operator.EQUAL ),
- fieldPath == $r1.fieldPath
+ fieldPath == $r1.fieldPath,
+ value < $r1.value
)
- eval( $r1.compareValues( $r2 ) == 1 )
-
$pp1 :SubPattern(
patternPath == $r1.patternPath
)
@@ -325,11 +323,10 @@
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 ),
- fieldPath == $r1.fieldPath
+ fieldPath == $r1.fieldPath,
+ valueAsString == $r1.valueAsString
)
- eval( $r1.compareValues( $r2 ) == 0 )
-
$pp1 :SubPattern(
patternPath == $r1.patternPath
)
@@ -464,11 +461,10 @@
rulePath == $r1.rulePath,
patternIsNot == false,
operator == Operator.EQUAL,
- fieldPath == $r1.fieldPath
+ fieldPath == $r1.fieldPath,
+ valueAsString == $r1.valueAsString
)
- eval( $r1.compareValues( $r2 ) == 0 )
-
$pp1 :SubPattern(
patternPath == $r1.patternPath
)
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incoherence/Restrictions.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incoherence/Restrictions.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incoherence/Restrictions.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -3,6 +3,7 @@
#list any import classes here.
import org.drools.verifier.components.LiteralRestriction;
+import org.drools.verifier.components.NumberRestriction;
import org.drools.verifier.components.SubPattern;
import org.drools.verifier.components.Pattern;
import org.drools.verifier.components.VariableRestriction;
@@ -45,11 +46,10 @@
valueType == $r1.valueType,
path != $r1.path,
# Operator needs to be reversed to what the other one has.
- eval( operator == MissingRange.getReversedOperator( $r1.getOperator() ))
+ eval( operator == MissingRange.getReversedOperator( $r1.getOperator() )),
+ valueAsString == $r1.valueAsString
)
- eval( $r1.compareValues( $r2 ) == 0 )
-
# There is a problem if both of these are in the same SubPattern.
$pp :SubPattern(
items contains $r1,
@@ -85,21 +85,20 @@
#
rule "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible ranges"
when
- $r1 :LiteralRestriction(
+ $r1 :NumberRestriction(
( operator == Operator.GREATER_OR_EQUAL || == Operator.GREATER )
)
- $r2 :LiteralRestriction(
+ $r2 :NumberRestriction(
patternPath == $r1.patternPath,
restrictionType == $r1.restrictionType,
fieldPath == $r1.fieldPath,
valueType == $r1.valueType,
( operator == Operator.LESS_OR_EQUAL || == Operator.LESS),
- path != $r1.path
+ path != $r1.path,
+ value < $r1.value
)
-
- eval( $r1.compareValues( $r2 ) == 1 )
-
+
# There is a problem if both of these are in the same SubPattern.
$pp :SubPattern(
items contains $r1,
@@ -135,21 +134,20 @@
#
rule "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible equality less or equal"
when
- $r1 :LiteralRestriction(
+ $r1 :NumberRestriction(
operator == Operator.EQUAL
)
- $r2 :LiteralRestriction(
+ $r2 :NumberRestriction(
patternPath == $r1.patternPath,
restrictionType == $r1.restrictionType,
fieldPath == $r1.fieldPath,
valueType == $r1.valueType,
( operator == Operator.LESS_OR_EQUAL || == Operator.LESS || == Operator.EQUAL ),
- path != $r1.path
+ path != $r1.path,
+ value < $r1.value
)
- eval( $r1.compareValues( $r2 ) == 1 )
-
# There is a problem if both of these are in the same SubPattern.
$pp :SubPattern(
items contains $r1,
@@ -185,21 +183,20 @@
#
rule "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible equality greater"
when
- $r1 :LiteralRestriction(
+ $r1 :NumberRestriction(
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL )
)
- $r2 :LiteralRestriction(
+ $r2 :NumberRestriction(
patternPath == $r1.patternPath,
restrictionType == $r1.restrictionType,
fieldPath == $r1.fieldPath,
valueType == $r1.valueType,
operator == Operator.EQUAL,
- path != $r1.path
+ path != $r1.path,
+ value < $r1.value
)
- eval( $r1.compareValues( $r2 ) == 1 )
-
# There is a problem if both of these are in the same SubPattern.
$pp :SubPattern(
items contains $r1,
@@ -245,11 +242,10 @@
fieldPath == $r1.fieldPath,
valueType == $r1.valueType,
operator == Operator.GREATER,
- path != $r1.path
+ path != $r1.path,
+ valueAsString == $r1.valueAsString
)
- eval( $r1.compareValues( $r2 ) == 0 )
-
# There is a problem if both of these are in the same SubPattern.
$pp :SubPattern(
items contains $r1,
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incompatibility/Restrictions.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incompatibility/Restrictions.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/incompatibility/Restrictions.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -3,6 +3,7 @@
#list any import classes here.
import org.drools.verifier.components.LiteralRestriction;
+import org.drools.verifier.components.NumberRestriction;
import org.drools.verifier.components.VariableRestriction;
import org.drools.verifier.report.components.Incompatibility;
@@ -18,19 +19,19 @@
#
rule "Incompatible LiteralRestrictions with ranges in pattern possibility, impossible equality less or equal"
when
- $r1 :LiteralRestriction(
+ $r1 :NumberRestriction(
operator == Operator.EQUAL
)
- $r2 :LiteralRestriction(
+ $r2 :NumberRestriction(
restrictionType == $r1.restrictionType,
fieldPath == $r1.fieldPath,
valueType == $r1.valueType,
( operator == Operator.LESS_OR_EQUAL || == Operator.LESS || == Operator.EQUAL ),
- path != $r1.path
+ path != $r1.path,
+ value < $r1.value
)
- eval( $r1.compareValues( $r2 ) == 1 )
then
insert( new Incompatibility( $r1, $r2 ) );
end
@@ -43,19 +44,19 @@
#
rule "Incompatible LiteralRestrictions with ranges in pattern possibility, impossible equality greater"
when
- $r1 :LiteralRestriction(
+ $r1 :NumberRestriction(
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL )
)
- $r2 :LiteralRestriction(
+ $r2 :NumberRestriction(
restrictionType == $r1.restrictionType,
fieldPath == $r1.fieldPath,
valueType == $r1.valueType,
operator == Operator.EQUAL,
- path != $r1.path
+ path != $r1.path,
+ value < $r1.value
)
- eval( $r1.compareValues( $r2 ) == 1 )
then
insert( new Incompatibility( $r1, $r2 ) );
end
@@ -77,10 +78,10 @@
fieldPath == $r1.fieldPath,
valueType == $r1.valueType,
operator == Operator.GREATER,
- path != $r1.path
+ path != $r1.path,
+ valueAsString == valueAsString
)
- eval( $r1.compareValues( $r2 ) == 0 )
then
insert( new Incompatibility( $r1, $r2 ) );
end
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/missingEquality/MissingEquality.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/missingEquality/MissingEquality.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/missingEquality/MissingEquality.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -8,6 +8,7 @@
import org.drools.verifier.components.VariableRestriction;
import org.drools.verifier.components.LiteralRestriction;
+import org.drools.verifier.components.NumberRestriction;
import org.drools.verifier.report.components.MissingRange;
import org.drools.verifier.report.components.VerifierMessage;
import org.drools.verifier.report.components.Severity;
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/opposites/Restrictions.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/opposites/Restrictions.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/opposites/Restrictions.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -3,6 +3,7 @@
#list any import classes here.
import org.drools.verifier.components.LiteralRestriction;
+import org.drools.verifier.components.NumberRestriction;
import org.drools.verifier.components.VariableRestriction;
import org.drools.verifier.components.Field;
@@ -39,11 +40,10 @@
valueType == $left.valueType,
path != $left.path,
# Operator needs to be reversed to what the other one has.
- eval( operator == MissingRange.getReversedOperator( $left.getOperator() ))
+ eval( operator == MissingRange.getReversedOperator( $left.getOperator() )),
+ valueAsString == valueAsString
)
- eval( $left.compareValues( $right ) == 0 )
-
# Check that there is not already a pair with these values.
not Opposites(
left == $left,
@@ -74,11 +74,10 @@
fieldPath == $left.fieldPath,
valueType == $left.valueType,
operator == Operator.LESS,
- path != $left.path
+ path != $left.path,
+ valueAsString == $left.valueAsString
)
- eval( $left.compareValues( $right ) == 0 )
-
# Check that there is not already a pair with these values.
not Opposites(
left == $left,
@@ -109,10 +108,9 @@
fieldPath == $left.fieldPath,
valueType == $left.valueType,
operator == Operator.LESS_OR_EQUAL,
- path != $left.path
+ path != $left.path,
+ valueAsString == $left.valueAsString
)
-
- eval( $left.compareValues( $right ) == 0 )
# Check that there is not already a pair with these values.
not Opposites(
@@ -136,21 +134,20 @@
#
rule "Opposite LiteralRestrictions with ranges, less - greater for ints and dates"
when
- $left :LiteralRestriction(
+ $left :NumberRestriction(
operator == Operator.LESS,
( valueType == Field.INT || == Field.DATE )
)
- $right :LiteralRestriction(
+ $right :NumberRestriction(
restrictionType == $left.restrictionType,
fieldPath == $left.fieldPath,
valueType == $left.valueType,
operator == Operator.GREATER,
- path != $left.path
+ path != $left.path,
+ value < $left.value
)
- eval( $left.compareValues( $right ) == 1 )
-
# Check that there is not already a pair with these values.
not Opposites(
left == $left,
@@ -172,21 +169,20 @@
#
rule "Opposite LiteralRestrictions with ranges, less or equal - greater or equal for ints and dates"
when
- $left :LiteralRestriction(
+ $left :NumberRestriction(
operator == Operator.GREATER_OR_EQUAL,
( valueType == Field.INT || == Field.DATE )
)
- $right :LiteralRestriction(
+ $right :NumberRestriction(
restrictionType == $left.restrictionType,
fieldPath == $left.fieldPath,
valueType == $left.valueType,
operator == Operator.LESS_OR_EQUAL,
- path != $left.path
+ path != $left.path,
+ value < $left.value
)
- eval( $left.compareValues( $right ) == 1 )
-
# Check that there is not already a pair with these values.
not Opposites(
left == $left,
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/overlaps/Restrictions.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/overlaps/Restrictions.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/overlaps/Restrictions.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -8,6 +8,7 @@
import org.drools.verifier.data.VerifierReport;
import org.drools.verifier.components.LiteralRestriction;
+import org.drools.verifier.components.NumberRestriction;
import org.drools.verifier.report.components.Subsumption;
import org.drools.verifier.report.components.Severity;
@@ -29,10 +30,36 @@
#
# Example 1: Pattern1( a > 10 ) and Pattern1( a > 100 )
#
-rule "Find overlapping restrictions"
+rule "Find overlapping number restrictions"
when
# There is subsumption between two restrictions
+ $left :NumberRestriction()
+ $right :NumberRestriction(
+ path != $left.path
+ )
+
+ $subsumption :Subsumption(
+ left.path == $left.path,
+ left.verifierComponentType == $left.verifierComponentType,
+ right.path == $right.path,
+ right.verifierComponentType == $right.verifierComponentType
+ )
+
+ # There is no restriction between these two restrictions.
+ not $center :NumberRestriction(
+ fieldPath == $left.fieldPath,
+ value == $left.value,
+ value > $right.value
+ )
+ then
+ insert( new Overlap( $left, $right ) );
+end
+
+rule "Find overlapping literal restrictions"
+ when
+ # There is subsumption between two restrictions
+
$left :LiteralRestriction()
$right :LiteralRestriction(
path != $left.path
@@ -48,10 +75,23 @@
# There is no restriction between these two restrictions.
not $center :LiteralRestriction(
fieldPath == $left.fieldPath,
- eval( $center.compareValues( $left ) == 1 ),
- eval( $center.compareValues( $right ) == -1 )
+ valueAsString == $left.valueAsString,
+ valueAsString == $right.valueAsString
)
then
insert( new Overlap( $left, $right ) );
end
+rule "Finddsds overlapping literal restrictions"
+ when
+ # There is subsumption between two restrictions
+
+ $left :LiteralRestriction()
+ $right :LiteralRestriction(
+ path != $left.path
+ )
+ then
+ System.out.println( "-----" + $left +" "+ $right);
+end
+
+
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Clean.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Clean.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Clean.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -85,34 +85,34 @@
@verifying_scopes(knowledge-package, decision-table)
when
# Covered x > 10
- $lower :LiteralRestriction(
+ $lower :NumberRestriction(
valueType == Field.INT,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL)
)
# Covered x < 100
- $higher :LiteralRestriction(
+ $higher :NumberRestriction(
fieldPath == $lower.fieldPath,
- intValue > $lower.intValue,
+ value > $lower.value,
patternIsNot == $lower.patternIsNot,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL)
)
# No "<" or "<=" restrictions between these two
- not LiteralRestriction(
+ not NumberRestriction(
( operator == Operator.LESS_OR_EQUAL || == Operator.LESS ),
fieldPath == $lower.fieldPath,
patternIsNot == $lower.patternIsNot,
- intValue > $lower.intValue,
- intValue < $higher.intValue
+ value > $lower.value,
+ value < $higher.value
)
# gap ( x < 50 ) or ( x > 50 ) or ( x <= 70 )
$gap :Gap(
restriction.fieldPath == $lower.fieldPath,
restriction.patternIsNot == $lower.patternIsNot,
- restriction.intValue > $lower.intValue,
- restriction.intValue < $higher.intValue
+ restriction.value > $lower.value,
+ restriction.value < $higher.value
)
then
retract( $gap );
@@ -138,34 +138,34 @@
@verifying_scopes(knowledge-package, decision-table)
when
# Covered x > 10
- $lower :LiteralRestriction(
+ $lower :NumberRestriction(
valueType == Field.INT,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL)
)
# Covered x < 100
- $higher :LiteralRestriction(
+ $higher :NumberRestriction(
fieldPath == $lower.fieldPath,
- intValue > $lower.intValue,
+ value > $lower.value,
patternIsNot == $lower.patternIsNot,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL)
)
# No "<" or "<=" restrictions between these two
- not LiteralRestriction(
+ not NumberRestriction(
( operator == Operator.GREATER_OR_EQUAL || == Operator.GREATER ),
fieldPath == $lower.fieldPath,
patternIsNot == $lower.patternIsNot,
- intValue > $lower.intValue,
- intValue < $higher.intValue
+ value > $lower.value,
+ value < $higher.value
)
# gap ( x < 50 ) or ( x > 50 ) or ( x >= 70 )
$gap :Gap(
restriction.fieldPath == $lower.fieldPath,
restriction.patternIsNot == $lower.patternIsNot,
- restriction.intValue > $lower.intValue,
- restriction.intValue < $higher.intValue
+ restriction.value > $lower.value,
+ restriction.value < $higher.value
)
then
retract( $gap );
@@ -191,34 +191,34 @@
@verifying_scopes(knowledge-package, decision-table)
when
# Covered x > 10.0
- $lower :LiteralRestriction(
+ $lower :NumberRestriction(
valueType == Field.DOUBLE,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL)
)
# Covered x < 100.0
- $higher :LiteralRestriction(
+ $higher :NumberRestriction(
fieldPath == $lower.fieldPath,
- doubleValue > $lower.doubleValue,
+ value > $lower.value,
patternIsNot == $lower.patternIsNot,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL)
)
# No "<" or "<=" restrictions between these two
- not LiteralRestriction(
+ not NumberRestriction(
( operator == Operator.LESS_OR_EQUAL || == Operator.LESS ),
fieldPath == $lower.fieldPath,
patternIsNot == $lower.patternIsNot,
- doubleValue > $lower.doubleValue,
- doubleValue < $higher.doubleValue
+ value > $lower.value,
+ value < $higher.value
)
# gap ( x < 50.0 ) or ( x > 50.0 ) or ( x <= 70.0 )
$gap :Gap(
restriction.fieldPath == $lower.fieldPath,
restriction.patternIsNot == $lower.patternIsNot,
- restriction.doubleValue > $lower.doubleValue,
- restriction.doubleValue < $higher.doubleValue
+ restriction.value > $lower.value,
+ restriction.value < $higher.value
)
then
retract( $gap );
@@ -244,34 +244,34 @@
@verifying_scopes(knowledge-package, decision-table)
when
# Covered x > 10.0
- $lower :LiteralRestriction(
+ $lower :NumberRestriction(
valueType == Field.DOUBLE,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL)
)
# Covered x < 100.0
- $higher :LiteralRestriction(
+ $higher :NumberRestriction(
fieldPath == $lower.fieldPath,
- doubleValue > $lower.doubleValue,
+ value > $lower.value,
patternIsNot == $lower.patternIsNot,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL)
)
# No "<" or "<=" restrictions between these two
- not LiteralRestriction(
+ not NumberRestriction(
( operator == Operator.GREATER_OR_EQUAL || == Operator.GREATER ),
fieldPath == $lower.fieldPath,
patternIsNot == $lower.patternIsNot,
- doubleValue > $lower.doubleValue,
- doubleValue < $higher.doubleValue
+ value > $lower.value,
+ value < $higher.value
)
# gap ( x < 50.0 ) or ( x > 50.0 ) or ( x >= 70.0 )
$gap :Gap(
restriction.fieldPath == $lower.fieldPath,
restriction.patternIsNot == $lower.patternIsNot,
- restriction.doubleValue > $lower.doubleValue,
- restriction.doubleValue < $higher.doubleValue
+ restriction.value > $lower.value,
+ restriction.value < $higher.value
)
then
retract( $gap );
@@ -297,34 +297,34 @@
@verifying_scopes(knowledge-package, decision-table)
when
# Covered x > "01-Oct-2007"
- $lower :LiteralRestriction(
+ $lower :DateRestriction(
valueType == Field.DATE,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL)
)
# Covered x < "20-Oct-2007"
- $higher :LiteralRestriction(
+ $higher :DateRestriction(
fieldPath == $lower.fieldPath,
patternIsNot == $lower.patternIsNot,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL),
- eval( dateValue.after( $lower.getDateValue() ) )
+ eval( value.after( $lower.getValue() ) )
)
# No "<" or "<=" restrictions between these two
- not LiteralRestriction(
+ not DateRestriction(
( operator == Operator.LESS_OR_EQUAL || == Operator.LESS ),
fieldPath == $lower.fieldPath,
patternIsNot == $lower.patternIsNot,
- eval( dateValue.after( $lower.getDateValue() ) ),
- eval( dateValue.before( $higher.getDateValue() ) )
+ eval( value.after( $lower.getValue() ) ),
+ eval( value.before( $higher.getValue() ) )
)
# gap ( x < "10-Oct-2007" ) or ( x > "10-Oct-2007" ) or ( x <= "15-Oct-2007" )
$gap :Gap(
restriction.fieldPath == $lower.fieldPath,
restriction.patternIsNot == $lower.patternIsNot,
- eval( restriction.getDateValue().after( $lower.getDateValue() ) ),
- eval( restriction.getDateValue().before( $higher.getDateValue() ) )
+ restriction.value > $lower.value,
+ restriction.value < $higher.value
)
then
retract( $gap );
@@ -350,36 +350,38 @@
@verifying_scopes(knowledge-package, decision-table)
when
# Covered x > "01-Oct-2007"
- $lower :LiteralRestriction(
+ $lower :DateRestriction(
valueType == Field.DATE,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL)
)
# Covered x < "20-Oct-2007"
- $higher :LiteralRestriction(
+ $higher :DateRestriction(
fieldPath == $lower.fieldPath,
patternIsNot == $lower.patternIsNot,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL),
- eval( dateValue.after( $lower.getDateValue() ) )
+ eval( value.after( $lower.getValue() ) )
)
# No ">" or ">=" restrictions between these two
- not LiteralRestriction(
+ not DateRestriction(
( operator == Operator.GREATER_OR_EQUAL || == Operator.GREATER ),
fieldPath == $lower.fieldPath,
patternIsNot == $lower.patternIsNot,
- eval( dateValue.after( $lower.getDateValue() ) ),
- eval( dateValue.before( $higher.getDateValue() ) )
+ eval( value.after( $lower.getValue() ) ),
+ eval( value.before( $higher.getValue() ) )
)
# gap ( x < "10-Oct-2007" ) or ( x > "10-Oct-2007" ) or ( x >= "15-Oct-2007" )
$gap :Gap(
restriction.fieldPath == $lower.fieldPath,
restriction.patternIsNot == $lower.patternIsNot,
- eval( restriction.getDateValue().after( $lower.getDateValue() ) ),
- eval( restriction.getDateValue().before( $higher.getDateValue() ) )
+ restriction.value > $lower.value,
+ restriction .value < $higher.value
)
then
retract( $gap );
result.remove( $gap );
end
+
+
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Dates.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Dates.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Dates.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -40,17 +40,17 @@
$f :Field( fieldType == Field.DATE )
# Foo( bar > "27-Oct-2007" )
- $r :LiteralRestriction(
+ $r :DateRestriction(
fieldPath == $f.path,
operator == Operator.GREATER
)
# Check if Foo( bar == "27-Oct-2007" || <= "27-Oct-2007" ) is missing.
- not LiteralRestriction(
+ not DateRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.LESS_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- eval( dateValue.equals($r.getDateValue()) )
+ value == $r.value
)
then
Gap gap = new Gap( $f, Operator.LESS_OR_EQUAL, $r );
@@ -72,17 +72,17 @@
$f :Field( fieldType == Field.DATE )
# Foo( bar > "27-Oct-2007" )
- $r :LiteralRestriction(
+ $r :DateRestriction(
fieldPath == $f.path,
operator == Operator.LESS
)
# Check if Foo( bar == "27-Oct-2007" || <= "27-Oct-2007" ) is missing.
- not LiteralRestriction(
+ not DateRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.GREATER_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- eval( dateValue.equals($r.getDateValue()) )
+ value == $r.value
)
then
Gap gap = new Gap( $f, Operator.GREATER_OR_EQUAL, $r );
@@ -105,25 +105,25 @@
$f :Field( fieldType == Field.DATE )
# Foo( bar == "27-Oct-2007" )
- $r :LiteralRestriction(
+ $r :DateRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.LESS_OR_EQUAL )
)
# Check if Foo( bar > "27-Oct-2007" || >= "27-Oct-2007" ) is missing.
- not LiteralRestriction(
+ not DateRestriction(
fieldPath == $f.path,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL ),
- patternIsNot == $r.patternIsNot,
- eval( dateValue.equals($r.getDateValue()) )
+ patternIsNot == $r.patternIsNot,
+ value == $r.value
)
# Check if Foo( bar == "28-Oct-2007" || >= "28-Oct-2007" ) is missing.
- not LiteralRestriction(
+ not DateRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.GREATER_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- eval( checkDates( dateValue, $r.getDateValue(), true ) )
+ eval( checkDates( value, $r.getValue(), true ) )
)
then
Gap gap = new Gap( $f, Operator.GREATER, $r );
@@ -146,25 +146,25 @@
$f :Field( fieldType == Field.DATE )
# Foo( bar == "27-Oct-2007" )
- $r :LiteralRestriction(
+ $r :DateRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.GREATER_OR_EQUAL )
)
# Check if Foo( bar < "27-Oct-2007" || <= "27-Oct-2007" ) is missing.
- not LiteralRestriction(
+ not DateRestriction(
fieldPath == $f.path,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- eval( dateValue.equals($r.getDateValue()) )
+ eval( value.equals($r.getValue()) )
)
# Check if Foo( bar == "26-Oct-2007" || <= "26-Oct-2007" ) is missing.
- not LiteralRestriction(
+ not DateRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.LESS_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- eval( checkDates( dateValue, $r.getDateValue(), false ) )
+ eval( checkDates( value, $r.getValue(), false ) )
)
then
Gap gap = new Gap( $f, Operator.LESS, $r );
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Doubles.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Doubles.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Doubles.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -26,17 +26,17 @@
$f :Field( fieldType == Field.DOUBLE )
# Foo( bar > 42 )
- $r :LiteralRestriction(
+ $r :NumberRestriction(
fieldPath == $f.path,
operator == Operator.GREATER
)
# Check if Foo( bar == 42 || <= 42 ) is missing.
- not LiteralRestriction(
+ not NumberRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.LESS_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- doubleValue == $r.doubleValue
+ value == $r.value
)
then
Gap gap = new Gap( $f, Operator.LESS_OR_EQUAL, $r );
@@ -58,17 +58,17 @@
$f :Field( fieldType == Field.DOUBLE )
# Foo( bar > 42 )
- $r :LiteralRestriction(
+ $r :NumberRestriction(
fieldPath == $f.path,
operator == Operator.LESS
)
# Check if Foo( bar == 42 || <= 42 ) is missing.
- not LiteralRestriction(
+ not NumberRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.GREATER_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- doubleValue == $r.doubleValue
+ value == $r.value
)
then
Gap gap = new Gap( $f, Operator.GREATER_OR_EQUAL, $r );
@@ -91,17 +91,17 @@
$f :Field( fieldType == Field.DOUBLE )
# Foo( bar == 42 )
- $r :LiteralRestriction(
+ $r :NumberRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.LESS_OR_EQUAL )
)
# Check if Foo( bar > 42 || >= 42 ) is missing.
- not LiteralRestriction(
+ not NumberRestriction(
fieldPath == $f.path,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- doubleValue == $r.doubleValue
+ value == $r.value
)
then
Gap gap = new Gap( $f, Operator.GREATER, $r );
@@ -124,17 +124,17 @@
$f :Field( fieldType == Field.DOUBLE )
# Foo( bar == 42 )
- $r :LiteralRestriction(
+ $r :NumberRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.GREATER_OR_EQUAL )
)
# Check if Foo( bar < 42 || <= 42 ) is missing.
- not LiteralRestriction(
+ not NumberRestriction(
fieldPath == $f.path,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- doubleValue == $r.doubleValue
+ value == $r.value
)
then
Gap gap = new Gap( $f, Operator.LESS, $r );
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Integers.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Integers.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/Integers.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -24,21 +24,21 @@
$f :Field( fieldType == Field.INT )
# Foo( bar > 42 )
- $r :LiteralRestriction(
+ $r :NumberRestriction(
fieldPath == $f.path,
operator == Operator.GREATER
)
# Check if Foo( bar == 42 || <= 42 ) is missing.
- not LiteralRestriction(
+ not NumberRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.LESS_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- intValue == $r.intValue
+ value == $r.value
)
then
Gap gap = new Gap( $f, Operator.LESS_OR_EQUAL, $r );
-
+
result.add( gap );
insert( gap );
end
@@ -56,17 +56,17 @@
$f :Field( fieldType == Field.INT )
# Foo( bar > 42 )
- $r :LiteralRestriction(
+ $r :NumberRestriction(
fieldPath == $f.path,
operator == Operator.LESS
)
# Check if Foo( bar == 42 || <= 42 ) is missing.
- not LiteralRestriction(
+ not NumberRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.GREATER_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- intValue == $r.intValue
+ value == $r.value
)
then
Gap gap = new Gap( $f, Operator.GREATER_OR_EQUAL, $r );
@@ -85,29 +85,30 @@
#
rule "Range check for integers, equal and greater than"
@verifying_scopes(knowledge-package, decision-table)
+ dialect "mvel"
when
$f :Field( fieldType == Field.INT )
# Foo( bar == 42 )
- $r :LiteralRestriction(
+ $r :NumberRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.LESS_OR_EQUAL )
)
# Check if Foo( bar > 42 || >= 42 ) is missing.
- not LiteralRestriction(
+ not NumberRestriction(
fieldPath == $f.path,
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- intValue == $r.intValue
+ value == $r.value
)
# Check if Foo( bar == 43 || >= 43 ) is missing.
- not LiteralRestriction(
+ not NumberRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.GREATER_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- eval( intValue == $r.getIntValue() + 1 )
+ value == ( $r.value + 1 )
)
then
Gap gap = new Gap( $f, Operator.GREATER, $r );
@@ -126,29 +127,30 @@
#
rule "Range check for integers, equal and smaller than"
@verifying_scopes(knowledge-package, decision-table)
+ dialect "mvel"
when
$f :Field( fieldType == Field.INT )
# Foo( bar == 42 )
- $r :LiteralRestriction(
+ $r :NumberRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.GREATER_OR_EQUAL )
)
# Check if Foo( bar < 42 || <= 42 ) is missing.
- not LiteralRestriction(
+ not NumberRestriction(
fieldPath == $f.path,
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- intValue == $r.intValue
+ value == $r.value
)
# Check if Foo( bar == 41 || <= 41 ) is missing.
- not LiteralRestriction(
+ not NumberRestriction(
fieldPath == $f.path,
( operator == Operator.EQUAL || == Operator.LESS_OR_EQUAL ),
patternIsNot == $r.patternIsNot,
- eval( intValue == $r.getIntValue() - 1 )
+ value == ( $r.value - 1 )
)
then
Gap gap = new Gap( $f, Operator.LESS, $r );
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/NumberPatterns.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/NumberPatterns.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/rangeChecks/NumberPatterns.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -47,7 +47,7 @@
LiteralRestriction(
fieldId == $f.path,
patternIsNot == true,
- operator == Operator.EQUAL
+ operator =valueator.EQUAL
)
)
)
@@ -88,7 +88,7 @@
from collect(
LiteralRestriction(
fieldId == $f.path,
- patternIsNot == true,
+ pavaluesNot == true,
operator == Operator.NOT_EQUAL
)
)
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/scope-knowledge-package.xml
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/scope-knowledge-package.xml 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/scope-knowledge-package.xml 2010-04-06 13:17:08 UTC (rev 32447)
@@ -33,9 +33,6 @@
<resource
source='classpath:org/drools/verifier/optimisation/PatternOrder.drl'
type='DRL' />
- <!-- Overlaps -->
- <resource source='classpath:org/drools/verifier/overlaps/Restrictions.drl'
- type='DRL' />
<!-- Range checks -->
<resource source='classpath:org/drools/verifier/rangeChecks/Clean.drl'
type='DRL' />
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/subsumption/Restrictions.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/subsumption/Restrictions.drl 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/subsumption/Restrictions.drl 2010-04-06 13:17:08 UTC (rev 32447)
@@ -5,6 +5,7 @@
import org.drools.verifier.components.Field;
import org.drools.verifier.components.LiteralRestriction;
+import org.drools.verifier.components.NumberRestriction;
import org.drools.verifier.report.components.Subsumption;
import org.drools.verifier.data.VerifierReport;
@@ -22,18 +23,17 @@
rule "Find subsumptant restrictions, greater than"
when
# Covered x > 10
- $lower:LiteralRestriction(
+ $lower:NumberRestriction(
( valueType == Field.INT || == Field.DOUBLE || == Field.DATE ),
( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL )
)
# Covered x > 100
- $higher :LiteralRestriction(
+ $higher :NumberRestriction(
fieldPath == $lower.fieldPath,
- ( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL || == Operator.EQUAL )
+ ( operator == Operator.GREATER || == Operator.GREATER_OR_EQUAL || == Operator.EQUAL ),
+ value < $lower.value
)
-
- eval( $lower.compareValues( $higher ) == -1 )
then
insert( new Subsumption( $higher, $lower ) );
end
@@ -47,10 +47,9 @@
$right :LiteralRestriction(
path != $left.path,
fieldPath == $left.fieldPath,
- operator == $left.operator
+ operator == $left.operator,
+ valueAsString == $left.valueAsString
)
-
- eval( $left.compareValues( $right ) == 0 )
then
insert( new Subsumption( $left, $right ) );
end
@@ -66,18 +65,17 @@
rule "Find subsumptant restrictions, less than"
when
# Covered x < 10
- $higher :LiteralRestriction(
+ $higher :NumberRestriction(
( valueType == Field.INT || == Field.DOUBLE || == Field.DATE ),
( operator == Operator.LESS || == Operator.LESS_OR_EQUAL )
)
# Covered x < 100
- $lower :LiteralRestriction(
+ $lower :NumberRestriction(
fieldPath == $higher.fieldPath,
- ( operator == Operator.LESS || == Operator.LESS_OR_EQUAL || == Operator.EQUAL)
+ ( operator == Operator.LESS || == Operator.LESS_OR_EQUAL || == Operator.EQUAL),
+ value < $higher.value
)
-
- eval( $lower.compareValues( $higher ) == - 1 )
then
insert( new Subsumption( $higher, $lower ) );
end
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/SolversTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/SolversTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/SolversTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -44,10 +44,14 @@
rule.setName( "testRule" );
Pattern pattern = new Pattern( rule );
- Restriction r = new LiteralRestriction( pattern );
- Restriction r2 = new LiteralRestriction( pattern );
- Restriction r3 = new LiteralRestriction( pattern );
- Restriction r4 = new LiteralRestriction( pattern );
+ Restriction r = LiteralRestriction.createRestriction( pattern,
+ "" );
+ Restriction r2 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ Restriction r3 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ Restriction r4 = LiteralRestriction.createRestriction( pattern,
+ "" );
Solvers solvers = new Solvers();
@@ -118,8 +122,10 @@
VerifierRule rule = VerifierComponentMockFactory.createRule1();
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- Restriction r = new LiteralRestriction( pattern );
- Restriction r2 = new LiteralRestriction( pattern );
+ Restriction r = LiteralRestriction.createRestriction( pattern,
+ "" );
+ Restriction r2 = LiteralRestriction.createRestriction( pattern,
+ "" );
Solvers solvers = new Solvers();
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/alwaysFalse/AlwaysFalseTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/alwaysFalse/AlwaysFalseTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/alwaysFalse/AlwaysFalseTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -43,8 +43,10 @@
// This pattern has an error.
Pattern pattern1 = VerifierComponentMockFactory.createPattern1();
- Restriction r1 = new LiteralRestriction( pattern1 );
- Restriction r2 = new LiteralRestriction( pattern1 );
+ Restriction r1 = LiteralRestriction.createRestriction( pattern1,
+ "" );
+ Restriction r2 = LiteralRestriction.createRestriction( pattern1,
+ "" );
Incompatibility i1 = new Incompatibility( r1,
r2 );
SubPattern pp1 = new SubPattern( pattern1,
@@ -64,8 +66,10 @@
// This pattern does not have an error.
Pattern pattern2 = VerifierComponentMockFactory.createPattern2();
- Restriction r5 = new LiteralRestriction( pattern2 );
- Restriction r6 = new LiteralRestriction( pattern2 );
+ Restriction r5 = LiteralRestriction.createRestriction( pattern2,
+ "" );
+ Restriction r6 = LiteralRestriction.createRestriction( pattern2,
+ "" );
SubPattern pp3 = new SubPattern( pattern2,
0 );
pp3.add( r5 );
@@ -207,7 +211,7 @@
// This pattern does not have an error.
VerifierRule rule2 = VerifierComponentMockFactory.createRule2();
- Pattern pattern2= VerifierComponentMockFactory.createPattern2();
+ Pattern pattern2 = VerifierComponentMockFactory.createPattern2();
SubPattern pp5 = new SubPattern( pattern2,
0 );
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/alwaysTrue/AlwaysTruePatternTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/alwaysTrue/AlwaysTruePatternTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/alwaysTrue/AlwaysTruePatternTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -48,8 +48,10 @@
// This pattern is always true.
Pattern pattern1 = VerifierComponentMockFactory.createPattern1();
- Restriction r1 = new LiteralRestriction( pattern1 );
- Restriction r2 = new LiteralRestriction( pattern1 );
+ Restriction r1 = LiteralRestriction.createRestriction( pattern1,
+ "" );
+ Restriction r2 = LiteralRestriction.createRestriction( pattern1,
+ "" );
Opposites o1 = new Opposites( r1,
r2 );
SubPattern pp1 = new SubPattern( pattern1,
@@ -69,8 +71,10 @@
// This pattern is okay.
Pattern pattern2 = VerifierComponentMockFactory.createPattern2();
- Restriction r5 = new LiteralRestriction( pattern2 );
- Restriction r6 = new LiteralRestriction( pattern2 );
+ Restriction r5 = LiteralRestriction.createRestriction( pattern2,
+ "" );
+ Restriction r6 = LiteralRestriction.createRestriction( pattern2,
+ "" );
SubPattern pp3 = new SubPattern( pattern2,
0 );
pp3.add( r5 );
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/components/LiteralRestrictionTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/components/LiteralRestrictionTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/components/LiteralRestrictionTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -10,52 +10,66 @@
Pattern pattern1 = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction booleanRestriction = new LiteralRestriction( pattern1 );
- booleanRestriction.setValue( "true" );
+ LiteralRestriction literalBooleanRestriction = LiteralRestriction.createRestriction( pattern1,
+ "true" );
+ assertTrue( literalBooleanRestriction instanceof BooleanRestriction );
+
+ BooleanRestriction booleanRestriction = (BooleanRestriction) literalBooleanRestriction;
+
assertEquals( Field.BOOLEAN,
booleanRestriction.getValueType() );
assertEquals( true,
- booleanRestriction.getBooleanValue() );
+ booleanRestriction.getValue() );
- LiteralRestriction intRestriction = new LiteralRestriction( pattern1 );
- intRestriction.setValue( "1" );
+ LiteralRestriction intLiteralRestriction = LiteralRestriction.createRestriction( pattern1,
+ "1" );
+ assertTrue( intLiteralRestriction instanceof NumberRestriction );
+ NumberRestriction intRestriction = (NumberRestriction) intLiteralRestriction;
+ assertTrue( intRestriction.isInt() );
assertEquals( Field.INT,
intRestriction.getValueType() );
assertEquals( 1,
- intRestriction.getIntValue() );
+ intRestriction.getValue() );
- LiteralRestriction doubleRestriction = new LiteralRestriction( pattern1 );
- doubleRestriction.setValue( "1.0" );
+ LiteralRestriction doubleLiteralRestriction = LiteralRestriction.createRestriction( pattern1,
+ "1.0" );
+ assertTrue( doubleLiteralRestriction instanceof NumberRestriction );
+ NumberRestriction doubleRestriction = (NumberRestriction) doubleLiteralRestriction;
+
assertEquals( Field.DOUBLE,
doubleRestriction.getValueType() );
assertEquals( 1.0,
- doubleRestriction.getDoubleValue() );
+ doubleRestriction.getValue() );
- LiteralRestriction dateRestriction = new LiteralRestriction( pattern1 );
- dateRestriction.setValue( "11-jan-2008" );
+ LiteralRestriction dateLiteralRestriction = LiteralRestriction.createRestriction( pattern1,
+ "11-jan-2008" );
+ assertTrue( dateLiteralRestriction instanceof DateRestriction );
+
+ DateRestriction dateRestriction = (DateRestriction) dateLiteralRestriction;
+
assertEquals( Field.DATE,
dateRestriction.getValueType() );
- LiteralRestriction stringRestriction = new LiteralRestriction( pattern1 );
- stringRestriction.setValue( "test test" );
+ LiteralRestriction stringRestriction = LiteralRestriction.createRestriction( pattern1,
+ "test test" );
assertEquals( Field.STRING,
stringRestriction.getValueType() );
assertEquals( "test test",
stringRestriction.getValueAsString() );
- LiteralRestriction nullRestriction = new LiteralRestriction( pattern1 );
- nullRestriction.setValue( null );
+ LiteralRestriction nullRestriction = LiteralRestriction.createRestriction( pattern1,
+ null );
+ assertTrue( nullRestriction instanceof StringRestriction );
+
assertEquals( Field.UNKNOWN,
nullRestriction.getValueType() );
- assertEquals( null,
+ assertEquals( "",
nullRestriction.getValueAsString() );
- assertEquals( null,
- nullRestriction.getValueAsObject() );
}
}
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/data/VerifierDataMapsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/data/VerifierDataMapsTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/data/VerifierDataMapsTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -113,7 +113,8 @@
public void testSaveVerifierComponentAndGetForAllRestrictions() {
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- saveVerifierComponentAndGet( new LiteralRestriction( pattern ) );
+ saveVerifierComponentAndGet( LiteralRestriction.createRestriction( pattern,
+ "" ) );
saveVerifierComponentAndGet( new EnumRestriction( pattern ) );
saveVerifierComponentAndGet( new QualifiedIdentifierRestriction( pattern ) );
saveVerifierComponentAndGet( new ReturnValueRestriction( pattern ) );
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incompatibility/IncompatibilityPatternsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incompatibility/IncompatibilityPatternsTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incompatibility/IncompatibilityPatternsTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -38,16 +38,20 @@
SubPattern pp2 = new SubPattern( pattern2,
0 );
- Restriction r1 = new LiteralRestriction( pattern1 );
+ Restriction r1 = LiteralRestriction.createRestriction( pattern1,
+ "" );
pp1.add( r1 );
- Restriction r2 = new LiteralRestriction( pattern2 );
+ Restriction r2 = LiteralRestriction.createRestriction( pattern2,
+ "" );
pp2.add( r2 );
- Restriction r3 = new LiteralRestriction( pattern1 );
+ Restriction r3 = LiteralRestriction.createRestriction( pattern1,
+ "" );
pp1.add( r3 );
- Restriction r4 = new LiteralRestriction( pattern2 );
+ Restriction r4 = LiteralRestriction.createRestriction( pattern2,
+ "" );
pp2.add( r4 );
Incompatibility o1 = new Incompatibility( r1,
@@ -65,16 +69,20 @@
SubPattern pp4 = new SubPattern( pattern4,
0 );
- Restriction r5 = new LiteralRestriction( pattern3 );
+ Restriction r5 = LiteralRestriction.createRestriction( pattern3,
+ "" );
pp3.add( r5 );
- Restriction r6 = new LiteralRestriction( pattern4 );
+ Restriction r6 = LiteralRestriction.createRestriction( pattern4,
+ "" );
pp4.add( r6 );
- Restriction r7 = new LiteralRestriction( pattern3 );
+ Restriction r7 = LiteralRestriction.createRestriction( pattern3,
+ "" );
pp3.add( r7 );
- Restriction r8 = new LiteralRestriction( pattern4 );
+ Restriction r8 = LiteralRestriction.createRestriction( pattern4,
+ "" );
pp4.add( r8 );
Incompatibility o3 = new Incompatibility( r5,
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incompatibility/IncompatibilityRestrictionsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incompatibility/IncompatibilityRestrictionsTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incompatibility/IncompatibilityRestrictionsTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -35,31 +35,31 @@
/*
* Working pair
*/
- LiteralRestriction r1 = new LiteralRestriction( pattern1 );
+ LiteralRestriction r1 = LiteralRestriction.createRestriction( pattern1,
+ "10" );
r1.setOperator( Operator.EQUAL );
r1.setFieldPath( "0" );
- r1.setValue( "10" );
r1.setOrderNumber( 0 );
- LiteralRestriction r2 = new LiteralRestriction( pattern1 );
+ LiteralRestriction r2 = LiteralRestriction.createRestriction( pattern1,
+ "1" );
r2.setOperator( Operator.LESS );
r2.setFieldPath( "0" );
- r2.setValue( "1" );
r2.setOrderNumber( 2 );
/*
* Pair that doesn't work.
*/
- LiteralRestriction r3 = new LiteralRestriction( pattern2 );
+ LiteralRestriction r3 = LiteralRestriction.createRestriction( pattern2,
+ "1" );
r3.setOperator( Operator.GREATER_OR_EQUAL );
r3.setFieldPath( "1" );
- r3.setValue( "1" );
r3.setOrderNumber( 0 );
- LiteralRestriction r4 = new LiteralRestriction( pattern2 );
+ LiteralRestriction r4 = LiteralRestriction.createRestriction( pattern2,
+ "10" );
r4.setOperator( Operator.EQUAL );
r4.setFieldPath( "1" );
- r4.setValue( "10" );
r4.setOrderNumber( 1 );
data.add( r1 );
@@ -96,31 +96,31 @@
/*
* Working pair
*/
- LiteralRestriction r1 = new LiteralRestriction( pattern1 );
+ LiteralRestriction r1 = LiteralRestriction.createRestriction( pattern1,
+ "10" );
r1.setOperator( Operator.GREATER );
r1.setFieldPath( "0" );
- r1.setValue( "10" );
r1.setOrderNumber( 0 );
- LiteralRestriction r2 = new LiteralRestriction( pattern1 );
+ LiteralRestriction r2 = LiteralRestriction.createRestriction( pattern1,
+ "1" );
r2.setOperator( Operator.EQUAL );
r2.setFieldPath( "0" );
- r2.setValue( "1" );
r2.setOrderNumber( 1 );
/*
* Pair that doesn't work.
*/
- LiteralRestriction r3 = new LiteralRestriction( pattern2 );
+ LiteralRestriction r3 = LiteralRestriction.createRestriction( pattern2,
+ "1" );
r3.setOperator( Operator.GREATER_OR_EQUAL );
r3.setFieldPath( "1" );
- r3.setValue( "1" );
r3.setOrderNumber( 0 );
- LiteralRestriction r4 = new LiteralRestriction( pattern2 );
+ LiteralRestriction r4 = LiteralRestriction.createRestriction( pattern2,
+ "10" );
r4.setOperator( Operator.EQUAL );
r4.setFieldPath( "1" );
- r4.setValue( "10" );
r4.setOrderNumber( 1 );
data.add( r1 );
@@ -157,31 +157,31 @@
/*
* Working pair
*/
- LiteralRestriction r1 = new LiteralRestriction( pattern1 );
+ LiteralRestriction r1 = LiteralRestriction.createRestriction( pattern1,
+ "10" );
r1.setOperator( Operator.GREATER );
r1.setFieldPath( "0" );
- r1.setValue( "10" );
r1.setOrderNumber( 0 );
- LiteralRestriction r2 = new LiteralRestriction( pattern1 );
+ LiteralRestriction r2 = LiteralRestriction.createRestriction( pattern1,
+ "10" );
r2.setOperator( Operator.LESS );
r2.setFieldPath( "0" );
- r2.setValue( "10" );
r2.setOrderNumber( 1 );
/*
* Pair that doesn't work.
*/
- LiteralRestriction r3 = new LiteralRestriction( pattern2 );
+ LiteralRestriction r3 = LiteralRestriction.createRestriction( pattern2,
+ "1" );
r3.setOperator( Operator.GREATER_OR_EQUAL );
r3.setFieldPath( "1" );
- r3.setValue( "1" );
r3.setOrderNumber( 0 );
- LiteralRestriction r4 = new LiteralRestriction( pattern2 );
+ LiteralRestriction r4 = LiteralRestriction.createRestriction( pattern2,
+ "" );
r4.setOperator( Operator.EQUAL );
r4.setFieldPath( "1" );
- r4.setValue( "10" );
r4.setOrderNumber( 1 );
data.add( r1 );
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/opposites/OppositePatternsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/opposites/OppositePatternsTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/opposites/OppositePatternsTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -37,16 +37,20 @@
SubPattern pp2 = new SubPattern( pattern,
1 );
- Restriction r1 = new LiteralRestriction( pattern );
+ Restriction r1 = LiteralRestriction.createRestriction( pattern,
+ "" );
pp1.add( r1 );
- Restriction r2 = new LiteralRestriction( pattern );
+ Restriction r2 = LiteralRestriction.createRestriction( pattern,
+ "" );
pp2.add( r2 );
- Restriction r3 = new LiteralRestriction( pattern );
+ Restriction r3 = LiteralRestriction.createRestriction( pattern,
+ "" );
pp1.add( r3 );
- Restriction r4 = new LiteralRestriction( pattern );
+ Restriction r4 = LiteralRestriction.createRestriction( pattern,
+ "" );
pp2.add( r4 );
Opposites o1 = new Opposites( r1,
@@ -62,16 +66,20 @@
SubPattern pp4 = new SubPattern( pattern,
3 );
- Restriction r5 = new LiteralRestriction( pattern );
+ Restriction r5 = LiteralRestriction.createRestriction( pattern,
+ "" );
pp3.add( r5 );
- Restriction r6 = new LiteralRestriction( pattern );
+ Restriction r6 = LiteralRestriction.createRestriction( pattern,
+ "" );
pp4.add( r6 );
- Restriction r7 = new LiteralRestriction( pattern );
+ Restriction r7 = LiteralRestriction.createRestriction( pattern,
+ "" );
pp3.add( r7 );
- Restriction r8 = new LiteralRestriction( pattern );
+ Restriction r8 = LiteralRestriction.createRestriction( pattern,
+ "" );
pp4.add( r8 );
Opposites o3 = new Opposites( r5,
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/opposites/OppositeRestrictionsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/opposites/OppositeRestrictionsTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/opposites/OppositeRestrictionsTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -31,40 +31,40 @@
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction r1 = new LiteralRestriction( pattern );
+ LiteralRestriction r1 = LiteralRestriction.createRestriction( pattern,
+ "1" );
r1.setFieldPath( "0" );
r1.setOperator( Operator.EQUAL );
- r1.setValue( "1" );
r1.setOrderNumber( 0 );
- LiteralRestriction r2 = new LiteralRestriction( pattern );
+ LiteralRestriction r2 = LiteralRestriction.createRestriction( pattern,
+ "1" );
r2.setFieldPath( "0" );
r2.setOperator( Operator.NOT_EQUAL );
- r2.setValue( "1" );
r2.setOrderNumber( 1 );
- LiteralRestriction r3 = new LiteralRestriction( pattern );
+ LiteralRestriction r3 = LiteralRestriction.createRestriction( pattern,
+ "1.0" );
r3.setFieldPath( "0" );
r3.setOperator( Operator.EQUAL );
- r3.setValue( "1.0" );
r3.setOrderNumber( 2 );
- LiteralRestriction r4 = new LiteralRestriction( pattern );
+ LiteralRestriction r4 = LiteralRestriction.createRestriction( pattern,
+ "1.0" );
r4.setFieldPath( "0" );
r4.setOperator( Operator.NOT_EQUAL );
- r4.setValue( "1.0" );
r4.setOrderNumber( 3 );
- LiteralRestriction r5 = new LiteralRestriction( pattern );
+ LiteralRestriction r5 = LiteralRestriction.createRestriction( pattern,
+ "foo" );
r5.setFieldPath( "0" );
r5.setOperator( MatchesEvaluatorsDefinition.MATCHES );
- r5.setValue( "foo" );
r5.setOrderNumber( 4 );
- LiteralRestriction r6 = new LiteralRestriction( pattern );
+ LiteralRestriction r6 = LiteralRestriction.createRestriction( pattern,
+ "foo" );
r6.setFieldPath( "0" );
r6.setOperator( MatchesEvaluatorsDefinition.NOT_MATCHES );
- r6.setValue( "foo" );
r6.setOrderNumber( 5 );
data.add( r1 );
@@ -109,16 +109,16 @@
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction r1 = new LiteralRestriction( pattern );
+ LiteralRestriction r1 = LiteralRestriction.createRestriction( pattern,
+ "1" );
r1.setFieldPath( "0" );
r1.setOperator( Operator.GREATER_OR_EQUAL );
- r1.setValue( "1" );
r1.setOrderNumber( 0 );
- LiteralRestriction r2 = new LiteralRestriction( pattern );
+ LiteralRestriction r2 = LiteralRestriction.createRestriction( pattern,
+ "1" );
r2.setFieldPath( "0" );
r2.setOperator( Operator.LESS );
- r2.setValue( "1" );
r2.setOrderNumber( 1 );
data.add( r1 );
@@ -148,16 +148,16 @@
Collection<Object> data = new ArrayList<Object>();
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction r1 = new LiteralRestriction( pattern );
+ LiteralRestriction r1 = LiteralRestriction.createRestriction( pattern,
+ "1" );
r1.setFieldPath( "0" );
r1.setOperator( Operator.GREATER );
- r1.setValue( "1" );
r1.setOrderNumber( 0 );
- LiteralRestriction r2 = new LiteralRestriction( pattern );
+ LiteralRestriction r2 = LiteralRestriction.createRestriction( pattern,
+ "1" );
r2.setFieldPath( "0" );
r2.setOperator( Operator.LESS_OR_EQUAL );
- r2.setValue( "1" );
r2.setOrderNumber( 1 );
data.add( r1 );
@@ -188,16 +188,16 @@
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction r1 = new LiteralRestriction( pattern );
+ LiteralRestriction r1 = LiteralRestriction.createRestriction( pattern,
+ "0" );
r1.setFieldPath( "0" );
r1.setOperator( Operator.GREATER );
- r1.setValue( "0" );
r1.setOrderNumber( 0 );
- LiteralRestriction r2 = new LiteralRestriction( pattern );
+ LiteralRestriction r2 = LiteralRestriction.createRestriction( pattern,
+ "1" );
r2.setFieldPath( "0" );
r2.setOperator( Operator.LESS );
- r2.setValue( "1" );
r2.setOrderNumber( 1 );
data.add( r1 );
@@ -228,16 +228,16 @@
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction r1 = new LiteralRestriction( pattern );
+ LiteralRestriction r1 = LiteralRestriction.createRestriction( pattern,
+ "1" );
r1.setFieldPath( "0" );
r1.setOperator( Operator.GREATER_OR_EQUAL );
- r1.setValue( "1" );
r1.setOrderNumber( 0 );
- LiteralRestriction r2 = new LiteralRestriction( pattern );
+ LiteralRestriction r2 = LiteralRestriction.createRestriction( pattern,
+ "0" );
r2.setFieldPath( "0" );
r2.setOperator( Operator.LESS_OR_EQUAL );
- r2.setValue( "0" );
r2.setOrderNumber( 1 );
data.add( r1 );
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/overlaps/OverlappingRestrictionsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/overlaps/OverlappingRestrictionsTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/overlaps/OverlappingRestrictionsTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -14,31 +14,35 @@
public class OverlappingRestrictionsTest extends TestBase {
- // TODO: Add this feature
- public void testOverlap() {
- VerifierBuilder vBuilder = VerifierBuilderFactory.newVerifierBuilder();
+ // TODO: Add this feature
+ public void FIXMEtestOverlap() {
+ VerifierBuilder vBuilder = VerifierBuilderFactory.newVerifierBuilder();
- Verifier verifier = vBuilder.newVerifier();
+ Verifier verifier = vBuilder.newVerifier();
- verifier.addResourcesToVerify( ResourceFactory.newClassPathResource( "RestrictionsTest.drl",
- getClass() ),
- ResourceType.DRL );
+ verifier.addResourcesToVerify(ResourceFactory.newClassPathResource(
+ "RestrictionsTest.drl", getClass()), ResourceType.DRL);
- assertFalse( verifier.hasErrors() );
+ assertFalse(verifier.hasErrors());
- boolean noProblems = verifier.fireAnalysis();
- assertTrue( noProblems );
+ boolean noProblems = verifier.fireAnalysis();
+ assertTrue(noProblems);
- Collection<Object> overlaps = ((VerifierImpl) verifier).getKnowledgeSession().getObjects( new ClassObjectFilter( Overlap.class ) );
+ Collection<Object> overlaps = ((VerifierImpl) verifier)
+ .getKnowledgeSession().getObjects(
+ new ClassObjectFilter(Overlap.class));
-// for ( Object object : overlaps ) {
-// System.out.println( object );
-// }
+ for (Object object : overlaps) {
+ System.out.println(object);
+ }
- assertEquals( 3,
- overlaps.size() );
+ assertEquals(3, overlaps.size());
- verifier.dispose();
+ verifier.dispose();
- }
+ }
+
+ public void testDUMMY() throws Exception {
+ assertTrue(true);
+ }
}
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/redundancy/NotesTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/redundancy/NotesTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/redundancy/NotesTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -30,9 +30,11 @@
Pattern pattern = VerifierComponentMockFactory.createPattern1();
Collection<Object> objects = new ArrayList<Object>();
- LiteralRestriction left = new LiteralRestriction( pattern );
+ LiteralRestriction left = LiteralRestriction.createRestriction( pattern,
+ "" );
- LiteralRestriction right = new LiteralRestriction( pattern );
+ LiteralRestriction right = LiteralRestriction.createRestriction( pattern,
+ "" );
Redundancy redundancy = new Redundancy( left,
right );
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/solver/PatternSolverTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/solver/PatternSolverTest.java 2010-04-06 13:08:08 UTC (rev 32446)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/solver/PatternSolverTest.java 2010-04-06 13:17:08 UTC (rev 32447)
@@ -31,8 +31,10 @@
public void testAddBasicAnd() {
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction literalRestriction = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction2 = new LiteralRestriction( pattern );
+ LiteralRestriction literalRestriction = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction2 = LiteralRestriction.createRestriction( pattern,
+ "" );
PatternSolver solver = new PatternSolver( pattern );
@@ -63,8 +65,10 @@
public void testAddBasicOr() {
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction literalRestriction = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction2 = new LiteralRestriction( pattern );
+ LiteralRestriction literalRestriction = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction2 = LiteralRestriction.createRestriction( pattern,
+ "" );
PatternSolver solver = new PatternSolver( pattern );
@@ -99,9 +103,12 @@
public void testAddOrAnd() {
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction literalRestriction = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction2 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction3 = new LiteralRestriction( pattern );
+ LiteralRestriction literalRestriction = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction2 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction3 = LiteralRestriction.createRestriction( pattern,
+ "" );
PatternSolver solver = new PatternSolver( pattern );
@@ -144,9 +151,12 @@
public void testAddAndOr() {
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction literalRestriction = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction2 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction3 = new LiteralRestriction( pattern );
+ LiteralRestriction literalRestriction = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction2 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction3 = LiteralRestriction.createRestriction( pattern,
+ "" );
PatternSolver solver = new PatternSolver( pattern );
@@ -194,10 +204,14 @@
public void testAddAndOrOr() {
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction literalRestriction = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction2 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction3 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction4 = new LiteralRestriction( pattern );
+ LiteralRestriction literalRestriction = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction2 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction3 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction4 = LiteralRestriction.createRestriction( pattern,
+ "" );
PatternSolver solver = new PatternSolver( pattern );
@@ -254,10 +268,14 @@
public void testAddOrAndAnd() {
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction literalRestriction = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction2 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction3 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction4 = new LiteralRestriction( pattern );
+ LiteralRestriction literalRestriction = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction2 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction3 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction4 = LiteralRestriction.createRestriction( pattern,
+ "" );
PatternSolver solver = new PatternSolver( pattern );
@@ -306,10 +324,14 @@
public void testAddOrAndOr() {
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction literalRestriction = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction2 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction3 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction4 = new LiteralRestriction( pattern );
+ LiteralRestriction literalRestriction = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction2 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction3 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction4 = LiteralRestriction.createRestriction( pattern,
+ "" );
PatternSolver solver = new PatternSolver( pattern );
@@ -359,11 +381,16 @@
public void testAddOrAndOrDescr() {
Pattern pattern = VerifierComponentMockFactory.createPattern1();
- LiteralRestriction literalRestriction = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction2 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction3 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction4 = new LiteralRestriction( pattern );
- LiteralRestriction literalRestriction5 = new LiteralRestriction( pattern );
+ LiteralRestriction literalRestriction = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction2 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction3 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction4 = LiteralRestriction.createRestriction( pattern,
+ "" );
+ LiteralRestriction literalRestriction5 = LiteralRestriction.createRestriction( pattern,
+ "" );
PatternSolver solver = new PatternSolver( pattern );
More information about the jboss-svn-commits
mailing list