[jboss-svn-commits] JBL Code SVN: r21239 - in labs/jbossrules/trunk/drools-verifier: src/main/java/org/drools/verifier and 12 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Sat Jul 26 10:36:25 EDT 2008
Author: Rikkola
Date: 2008-07-26 10:36:25 -0400 (Sat, 26 Jul 2008)
New Revision: 21239
Modified:
labs/jbossrules/trunk/drools-verifier/.classpath
labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/Verifier.java
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/Consequence.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/alwaysFalse/Patterns.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/alwaysTrue/Patterns.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/optimisation/RestrictionOrder.drl
labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/redundancy/Possibilities.drl
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/ConsequenceTest.java
labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/VerifierTest.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/incoherence/IncoherentRestrictionsTest.java
labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/Enums.drl
labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/incoherence/RestrictionsTest.drl
labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/optimisation/OptimisationPatternOrderTest.drl
Log:
If the drl file that is under testing fails to load. Unit test that is checking this file now fails the test instead of throwing a NullPointerException.
Modified: labs/jbossrules/trunk/drools-verifier/.classpath
===================================================================
--- labs/jbossrules/trunk/drools-verifier/.classpath 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/.classpath 2008-07-26 14:36:25 UTC (rev 21239)
@@ -5,13 +5,27 @@
<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/com/thoughtworks/xstream/xstream/1.2.2/xstream-1.2.2.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="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/junit/junit/3.8.1/junit-3.8.1.jar"/>
+ <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="src" path="/drools-core"/>
- <classpathentry kind="var" path="M2_REPO/org/mvel/mvel/2.0-dp4/mvel-2.0-dp4.jar"/>
- <classpathentry kind="var" path="M2_REPO/org/antlr/antlr-runtime/3.0/antlr-runtime-3.0.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/mvel/mvel/2.0-dp4/mvel-2.0-dp4.jar" sourcepath="M2_REPO/org/mvel/mvel/2.0-dp4/mvel-2.0-dp4-sources.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/antlr/antlr-runtime/3.0.1/antlr-runtime-3.0.1.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/antlr/stringtemplate/3.1-b1/stringtemplate-3.1-b1.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/antlr/gunit/1.0.1/gunit-1.0.1.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/apache/maven/maven-project/2.0/maven-project-2.0.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/apache/maven/maven-profile/2.0/maven-profile-2.0.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/apache/maven/maven-model/2.0/maven-model-2.0.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/codehaus/plexus/plexus-utils/1.0.4/plexus-utils-1.0.4.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/codehaus/plexus/plexus-container-default/1.0-alpha-8/plexus-container-default-1.0-alpha-8.jar"/>
+ <classpathentry kind="var" path="M2_REPO/classworlds/classworlds/1.1-alpha-2/classworlds-1.1-alpha-2.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/apache/maven/maven-artifact-manager/2.0/maven-artifact-manager-2.0.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/apache/maven/maven-repository-metadata/2.0/maven-repository-metadata-2.0.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/apache/maven/maven-artifact/2.0/maven-artifact-2.0.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/apache/maven/wagon/wagon-provider-api/1.0-alpha-5/wagon-provider-api-1.0-alpha-5.jar"/>
+ <classpathentry kind="var" path="M2_REPO/org/antlr/antlr/3.0.1/antlr-3.0.1.jar"/>
+ <classpathentry kind="var" path="M2_REPO/antlr/antlr/2.7.7/antlr-2.7.7.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/janino/janino/2.5.10/janino-2.5.10.jar"/>
</classpath>
\ No newline at end of file
Modified: labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/Verifier.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/Verifier.java 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/main/java/org/drools/verifier/Verifier.java 2008-07-26 14:36:25 UTC (rev 21239)
@@ -20,113 +20,119 @@
*/
public class Verifier {
- static RuleBase verifierKnowledgeBase;
+ static RuleBase verifierKnowledgeBase;
+ private VerifierResult result = VerifierResultFactory.createVerifierResult();
- private VerifierResult result = VerifierResultFactory
- .createVerifierResult();
+ public void addPackageDescr(PackageDescr descr) {
+ try {
- public void addPackageDescr(PackageDescr descr) {
- try {
+ PackageDescrFlattener ruleFlattener = new PackageDescrFlattener();
- PackageDescrFlattener ruleFlattener = new PackageDescrFlattener();
+ ruleFlattener.addPackageDescrToData( descr,
+ result.getVerifierData() );
- ruleFlattener.addPackageDescrToData(descr, result
- .getVerifierData());
+ } catch ( Throwable t ) {
+ t.printStackTrace();
+ }
+ }
- } catch (Throwable t) {
- t.printStackTrace();
- }
- }
+ /**
+ * As the analyzer uses rules itself, this will reload the knowledge base.
+ * @throws Exception
+ */
+ public synchronized void reloadAnalysisKnowledgeBase() throws Exception {
+ verifierKnowledgeBase = createRuleBase();
+ }
+ /**
+ *
+ * This will run the verifier.
+ *
+ * @return true if everything worked.
+ */
+ public boolean fireAnalysis() {
+ try {
- /**
- * As the analyzer uses rules itself, this will reload the knowledge base.
- * @throws Exception
- */
- public synchronized void reloadAnalysisKnowledgeBase() throws Exception {
- verifierKnowledgeBase = createRuleBase();
- }
+ if ( this.verifierKnowledgeBase == null ) {
+ synchronized ( this.getClass() ) {
+ verifierKnowledgeBase = createRuleBase();
+ }
+ }
- /**
- * This will run the verifier.
- */
- public void fireAnalysis() {
- try {
+ WorkingMemory workingMemory = verifierKnowledgeBase.newStatefulSession();
- if (this.verifierKnowledgeBase == null) {
- synchronized (this.getClass()) {
- verifierKnowledgeBase = createRuleBase();
- }
- }
+ Collection< ? extends Object> c = result.getVerifierData().getAll();
- WorkingMemory workingMemory = verifierKnowledgeBase.newStatefulSession();
+ for ( Object o : c ) {
+ workingMemory.insert( o );
+ }
- Collection<? extends Object> c = result.getVerifierData().getAll();
+ // Object that returns the results.
+ workingMemory.setGlobal( "result",
+ result );
+ workingMemory.fireAllRules();
- for (Object o : c) {
- workingMemory.insert(o);
- }
+ } catch ( Throwable t ) {
+ t.printStackTrace();
- // Object that returns the results.
- workingMemory.setGlobal("result", result);
- workingMemory.fireAllRules();
+ return false;
+ }
- } catch (Throwable t) {
- t.printStackTrace();
- }
- }
+ return true;
+ }
- /**
- * Returns the verifier results as plain text.
- *
- * @return Analysis results as plain text.
- */
- public String getResultAsPlainText() {
- return ReportModeller.writePlainText(result);
- }
+ /**
+ * Returns the verifier results as plain text.
+ *
+ * @return Analysis results as plain text.
+ */
+ public String getResultAsPlainText() {
+ return ReportModeller.writePlainText( result );
+ }
- /**
- * Returns the verifier results as XML.
- *
- * @return Analysis results as XML
- */
- public String getResultAsXML() {
- return ReportModeller.writeXML(result);
- }
+ /**
+ * Returns the verifier results as XML.
+ *
+ * @return Analysis results as XML
+ */
+ public String getResultAsXML() {
+ return ReportModeller.writeXML( result );
+ }
- /**
- * Returns the verifier results as HTML.
- *
- * @return Analysis results as HTML
- */
- public void writeComponentsHTML(String path) {
- ComponentsReportModeller.writeHTML(path, result);
- }
+ /**
+ * Returns the verifier results as HTML.
+ *
+ * @return Analysis results as HTML
+ */
+ public void writeComponentsHTML(String path) {
+ ComponentsReportModeller.writeHTML( path,
+ result );
+ }
- /**
- * Returns the verifier results as <code>AnalysisResult</code> object.
- *
- * @return Analysis result
- */
- public VerifierResult getResult() {
- return result;
- }
+ /**
+ * Returns the verifier results as <code>AnalysisResult</code> object.
+ *
+ * @return Analysis result
+ */
+ public VerifierResult getResult() {
+ return result;
+ }
- private static RuleBase createRuleBase() throws Exception {
+ private static RuleBase createRuleBase() throws Exception {
- RuleBase ruleBase = RuleBaseFactory.newRuleBase();
+ RuleBase ruleBase = RuleBaseFactory.newRuleBase();
- Collection<Package> packages = RuleLoader.loadPackages();
- for (Package pkg : packages) {
- try {
- ruleBase.addPackage(pkg);
- } catch (Exception e) {
- throw new Exception("Adding package " + pkg.getName()
- + " caused an error.", e);
- }
- }
+ Collection<Package> packages = RuleLoader.loadPackages();
+ for ( Package pkg : packages ) {
+ try {
+ ruleBase.addPackage( pkg );
+ } catch ( Exception e ) {
+ throw new Exception( "Adding package " + pkg.getName() + " caused an error.",
+ e );
+ }
+ }
- return ruleBase;
- }
+ return ruleBase;
+ }
}
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/Consequence.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/Consequence.drl 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/Consequence.drl 2008-07-26 14:36:25 UTC (rev 21239)
@@ -15,9 +15,7 @@
rule "No action - possibly commented out"
when
- $c :TextConsequence(
- ( text == null || text matches "" )
- )
+ $c :TextConsequence( ( text == null || matches "" ) )
$r :VerifierRule(
id == $c.ruleId
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/alwaysFalse/Patterns.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/alwaysFalse/Patterns.drl 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/alwaysFalse/Patterns.drl 2008-07-26 14:36:25 UTC (rev 21239)
@@ -8,6 +8,7 @@
#list any import classes here.
import org.drools.verifier.components.Pattern;
import org.drools.verifier.components.PatternPossibility;
+import org.drools.verifier.components.VerifierRule;
import org.drools.verifier.report.components.Severity;
import org.drools.verifier.report.components.MessageType;
@@ -36,6 +37,9 @@
when
$p :Pattern()
+ # Check that there is at least one pattern possibility.
+ exists PatternPossibility( patternId == $p.id )
+
# All the pattern possibilities for pattern need to be in conflict
forall(
$pp :PatternPossibility(
@@ -47,11 +51,13 @@
right memberOf $pp.items
)
)
+
+ $r :VerifierRule( id == $p.ruleId )
then
# Report an error
result.add( new VerifierMessage(
Severity.ERROR,
MessageType.ALWAYS_FALSE,
$p,
- $p + " can never be satisfied." ) );
+ $p + " in " + $r + " can never be satisfied." ) );
end
\ No newline at end of file
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/alwaysTrue/Patterns.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/alwaysTrue/Patterns.drl 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/alwaysTrue/Patterns.drl 2008-07-26 14:36:25 UTC (rev 21239)
@@ -10,6 +10,7 @@
import org.drools.verifier.components.Restriction;
import org.drools.verifier.components.Pattern;
import org.drools.verifier.components.PatternPossibility;
+import org.drools.verifier.components.VerifierRule;
import org.drools.verifier.report.components.AlwaysTrue;
import org.drools.verifier.report.components.Opposites;
@@ -21,6 +22,25 @@
global VerifierResult result;
+
+
+rule "Pattern possibility that is always true"
+ when
+ a :Restriction()
+ b :Restriction()
+ $pp :PatternPossibility()
+
+ Opposites(
+ (
+ left == a && right memberof $pp.items
+ ) && (
+ left == b && right memberof $pp.items
+ )
+ )
+ then
+# insert( new AlwaysTrue( $pp ));
+end
+/*
#
# Finds pattern possibilities that are always true.
#
@@ -75,6 +95,9 @@
when
$p :Pattern()
+ # Only report the ones that have restrictions.
+ exists PatternPossibility( patternId == $p.id )
+
# For each restriction in each pattern possibility for current pattern,
# there needs to be an opposite.
forall(
@@ -86,10 +109,13 @@
cause == $pp
)
)
+
+ $r :VerifierRule( id == $p.ruleId )
then
result.add( new VerifierMessage(
Severity.NOTE,
MessageType.ALWAYS_TRUE,
$p,
- $p + " is always satisfied." ) );
-end
\ No newline at end of file
+ $p + " in rule " + $r + " is always satisfied." ) );
+end
+*/
\ No newline at end of file
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/optimisation/RestrictionOrder.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/optimisation/RestrictionOrder.drl 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/optimisation/RestrictionOrder.drl 2008-07-26 14:36:25 UTC (rev 21239)
@@ -145,19 +145,29 @@
$r2 :Restriction(
parent == $r1.parent,
orderNumber < $r1.orderNumber,
- ( operator == Operator.GREATER || == Operator.LESS || == Operator.GREATER_OR_EQUAL || == Operator.LESS_OR_EQUAL || == MatchesEvaluatorsDefinition.NOT_MATCHES || == Operator.NOT_EQUAL )
+ ( operator == Operator.GREATER ||
+ == Operator.LESS ||
+ == Operator.GREATER_OR_EQUAL ||
+ == Operator.LESS_OR_EQUAL ||
+ == MatchesEvaluatorsDefinition.NOT_MATCHES ||
+ == Operator.NOT_EQUAL )
)
) or (
$r1 :Restriction(
- ( operator == Operator.GREATER || == Operator.LESS )
+ ( operator == Operator.GREATER ||
+ == Operator.LESS )
)
and
$r2 :Restriction(
parent == $r1.parent,
orderNumber < $r1.orderNumber,
- ( operator == Operator.GREATER_OR_EQUAL || == Operator.LESS_OR_EQUAL || == MatchesEvaluatorsDefinition.NOT_MATCHES || == Operator.NOT_EQUAL )
+ ( operator == Operator.GREATER_OR_EQUAL ||
+ == Operator.LESS_OR_EQUAL ||
+ == MatchesEvaluatorsDefinition.NOT_MATCHES ||
+ == Operator.NOT_EQUAL )
)
- ) or (
+ )
+ or (
$r1 :Restriction(
( operator == Operator.GREATER_OR_EQUAL || == Operator.LESS_OR_EQUAL )
)
Modified: labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/redundancy/Possibilities.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/redundancy/Possibilities.drl 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/main/resources/org/drools/verifier/redundancy/Possibilities.drl 2008-07-26 14:36:25 UTC (rev 21239)
@@ -69,7 +69,6 @@
&&
right == $r
)
-
)
)
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/ConsequenceTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/ConsequenceTest.java 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/ConsequenceTest.java 2008-07-26 14:36:25 UTC (rev 21239)
@@ -1,5 +1,6 @@
package org.drools.verifier;
+import java.io.InputStream;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
@@ -21,44 +22,43 @@
*/
public class ConsequenceTest extends TestBase {
- public void testMissingConsequence() throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Consequence.drl"));
+ public void testMissingConsequence() throws Exception {
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "No action - possibly commented out"));
+ InputStream in = getClass().getResourceAsStream( "Consequence.drl" );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
+ StatelessSession session = getStatelessSession( in );
- Collection<? extends Object> testData = getTestData(this.getClass()
- .getResourceAsStream("ConsequenceTest.drl"), result
- .getVerifierData());
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "No action - possibly commented out" ) );
- session.setGlobal("result", result);
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
- session.executeWithResults(testData);
+ Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "ConsequenceTest.drl" ),
+ result.getVerifierData() );
- Iterator<VerifierMessageBase> iter = result.getBySeverity(
- Severity.WARNING).iterator();
+ session.setGlobal( "result",
+ result );
- Set<String> rulesThatHadErrors = new HashSet<String>();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- VerifierRule rule = (VerifierRule) ((VerifierMessage) o)
- .getFaulty();
- rulesThatHadErrors.add(rule.getRuleName());
- }
- }
+ session.executeWithResults( testData );
- assertFalse(rulesThatHadErrors.contains("Has a consequence 1"));
- assertTrue(rulesThatHadErrors.remove("Missing consequence 1"));
- assertTrue(rulesThatHadErrors.remove("Missing consequence 2"));
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.WARNING ).iterator();
- if (!rulesThatHadErrors.isEmpty()) {
- for (String string : rulesThatHadErrors) {
- fail("Rule " + string + " caused an error.");
- }
- }
- }
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ VerifierRule rule = (VerifierRule) ((VerifierMessage) o).getFaulty();
+ rulesThatHadErrors.add( rule.getRuleName() );
+ }
+ }
+
+ assertFalse( rulesThatHadErrors.contains( "Has a consequence 1" ) );
+ assertTrue( rulesThatHadErrors.remove( "Missing consequence 1" ) );
+ assertTrue( rulesThatHadErrors.remove( "Missing consequence 2" ) );
+
+ if ( !rulesThatHadErrors.isEmpty() ) {
+ for ( String string : rulesThatHadErrors ) {
+ fail( "Rule " + string + " caused an error." );
+ }
+ }
+ }
}
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/VerifierTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/VerifierTest.java 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/VerifierTest.java 2008-07-26 14:36:25 UTC (rev 21239)
@@ -13,66 +13,76 @@
public class VerifierTest extends TestCase {
- public void testAnalyzer() throws Exception {
- Verifier anal = new Verifier();
+ public void testAnalyzer() throws Exception {
+ Verifier anal = new Verifier();
- DrlParser p = new DrlParser();
- InputStreamReader reader = new InputStreamReader(this.getClass().getResourceAsStream("Misc3.drl"));
- PackageDescr pkg = p.parse(reader);
- assertFalse(p.hasErrors());
+ DrlParser p = new DrlParser();
+ InputStreamReader reader = new InputStreamReader( this.getClass().getResourceAsStream( "Misc3.drl" ) );
+ PackageDescr pkg = p.parse( reader );
+ assertFalse( p.hasErrors() );
- anal.addPackageDescr(pkg);
- anal.fireAnalysis();
+ anal.addPackageDescr( pkg );
+ assertTrue( "Firing verifier failed.",
+ anal.fireAnalysis() );
- VerifierResult result = anal.getResult();
- assertNotNull(result);
- assertEquals(0, result.getBySeverity(Severity.ERROR).size());
- assertEquals(10, result.getBySeverity(Severity.WARNING).size());
- assertEquals(16, result.getBySeverity(Severity.NOTE).size());
+ VerifierResult result = anal.getResult();
+ assertNotNull( result );
+ assertEquals( 0,
+ result.getBySeverity( Severity.ERROR ).size() );
+ assertEquals( 10,
+ result.getBySeverity( Severity.WARNING ).size() );
+ assertEquals( 16,
+ result.getBySeverity( Severity.NOTE ).size() );
+ //check it again
+ anal = new Verifier();
- //check it again
- anal = new Verifier();
+ p = new DrlParser();
+ reader = new InputStreamReader( this.getClass().getResourceAsStream( "Misc3.drl" ) );
+ pkg = p.parse( reader );
+ assertFalse( p.hasErrors() );
- p = new DrlParser();
- reader = new InputStreamReader(this.getClass().getResourceAsStream("Misc3.drl"));
- pkg = p.parse(reader);
- assertFalse(p.hasErrors());
+ anal.addPackageDescr( pkg );
+ assertTrue( "Firing verifier failed.",
+ anal.fireAnalysis() );
- anal.addPackageDescr(pkg);
- anal.fireAnalysis();
+ result = anal.getResult();
+ assertNotNull( result );
+ assertEquals( 0,
+ result.getBySeverity( Severity.ERROR ).size() );
+ assertEquals( 10,
+ result.getBySeverity( Severity.WARNING ).size() );
+ assertEquals( 16,
+ result.getBySeverity( Severity.NOTE ).size() );
- result = anal.getResult();
- assertNotNull(result);
- assertEquals(0, result.getBySeverity(Severity.ERROR).size());
- assertEquals(10, result.getBySeverity(Severity.WARNING).size());
- assertEquals(16, result.getBySeverity(Severity.NOTE).size());
+ }
+ public void testCacheKnowledgeBase() throws Exception {
+ Verifier anal = new Verifier();
+ DrlParser p = new DrlParser();
+ InputStreamReader reader = new InputStreamReader( this.getClass().getResourceAsStream( "Misc3.drl" ) );
+ PackageDescr pkg = p.parse( reader );
+ assertFalse( p.hasErrors() );
+ anal.addPackageDescr( pkg );
+ anal.fireAnalysis();
+ RuleBase original = Verifier.verifierKnowledgeBase;
- }
+ Verifier anal2 = new Verifier();
- public void testCacheKnowledgeBase() throws Exception {
- Verifier anal = new Verifier();
- DrlParser p = new DrlParser();
- InputStreamReader reader = new InputStreamReader(this.getClass().getResourceAsStream("Misc3.drl"));
- PackageDescr pkg = p.parse(reader);
- assertFalse(p.hasErrors());
+ assertSame( original,
+ Verifier.verifierKnowledgeBase );
- anal.addPackageDescr(pkg);
- anal.fireAnalysis();
+ try {
+ anal2.reloadAnalysisKnowledgeBase();
+ } catch ( Exception e ) {
+ fail( "Couldn't reload the knowledge base." );
+ }
- RuleBase original = Verifier.verifierKnowledgeBase;
+ assertNotSame( original,
+ Verifier.verifierKnowledgeBase );
- Verifier anal2 = new Verifier();
+ }
- assertSame(original, Verifier.verifierKnowledgeBase);
-
- anal2.reloadAnalysisKnowledgeBase();
- assertNotSame(original, Verifier.verifierKnowledgeBase);
-
-
- }
-
}
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 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/alwaysFalse/AlwaysFalseTest.java 2008-07-26 14:36:25 UTC (rev 21239)
@@ -28,187 +28,242 @@
*/
public class AlwaysFalseTest extends TestBase {
- public void testPatterns() throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Patterns.drl"));
+ public void testPatterns() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Patterns.drl" ) );
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Pattern that is always false"));
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Pattern that is always false" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<Object> data = new ArrayList<Object>();
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection<Object> data = new ArrayList<Object>();
- session.setGlobal("result", result);
+ session.setGlobal( "result",
+ result );
- // This pattern has an error.
- Pattern pattern1 = new Pattern();
+ // This pattern has an error.
+ VerifierRule rule1 = new VerifierRule();
+ Pattern pattern1 = new Pattern();
+ pattern1.setRuleId( rule1.getId() );
- Restriction r1 = new LiteralRestriction();
- Restriction r2 = new LiteralRestriction();
- Incompatibility i1 = new Incompatibility(r1, r2);
- PatternPossibility pp1 = new PatternPossibility();
- pp1.setPatternId(pattern1.getId());
- pp1.add(r1);
- pp1.add(r2);
+ Restriction r1 = new LiteralRestriction();
+ Restriction r2 = new LiteralRestriction();
+ Incompatibility i1 = new Incompatibility( r1,
+ r2 );
+ PatternPossibility pp1 = new PatternPossibility();
+ pp1.setPatternId( pattern1.getId() );
+ pp1.add( r1 );
+ pp1.add( r2 );
- Restriction r3 = new VariableRestriction();
- Restriction r4 = new VariableRestriction();
- Incompatibility i2 = new Incompatibility(r1, r2);
- PatternPossibility pp2 = new PatternPossibility();
- pp2.setPatternId(pattern1.getId());
- pp2.add(r1);
- pp2.add(r2);
+ Restriction r3 = new VariableRestriction();
+ Restriction r4 = new VariableRestriction();
+ Incompatibility i2 = new Incompatibility( r1,
+ r2 );
+ PatternPossibility pp2 = new PatternPossibility();
+ pp2.setPatternId( pattern1.getId() );
+ pp2.add( r1 );
+ pp2.add( r2 );
- // This pattern does not have an error.
- Pattern pattern2 = new Pattern();
+ // This pattern does not have an error.
+ Pattern pattern2 = new Pattern();
+ pattern2.setRuleId( rule1.getId() );
- Restriction r5 = new LiteralRestriction();
- Restriction r6 = new LiteralRestriction();
- PatternPossibility pp3 = new PatternPossibility();
- pp3.setPatternId(pattern2.getId());
- pp3.add(r5);
- pp3.add(r6);
+ Restriction r5 = new LiteralRestriction();
+ Restriction r6 = new LiteralRestriction();
+ PatternPossibility pp3 = new PatternPossibility();
+ pp3.setPatternId( pattern2.getId() );
+ pp3.add( r5 );
+ pp3.add( r6 );
- Restriction r7 = new VariableRestriction();
- Restriction r8 = new VariableRestriction();
- Incompatibility i4 = new Incompatibility(r7, r8);
- PatternPossibility pp4 = new PatternPossibility();
- pp4.setPatternId(pattern2.getId());
- pp4.add(r7);
- pp4.add(r8);
+ Restriction r7 = new VariableRestriction();
+ Restriction r8 = new VariableRestriction();
+ Incompatibility i4 = new Incompatibility( r7,
+ r8 );
+ PatternPossibility pp4 = new PatternPossibility();
+ pp4.setPatternId( pattern2.getId() );
+ pp4.add( r7 );
+ pp4.add( r8 );
- data.add(pattern1);
- data.add(r1);
- data.add(r2);
- data.add(r3);
- data.add(r4);
- data.add(i1);
- data.add(i2);
- data.add(pp1);
- data.add(pp2);
+ data.add( rule1 );
- data.add(pattern2);
- data.add(r5);
- data.add(r6);
- data.add(r7);
- data.add(r8);
- data.add(i4);
- data.add(pp3);
- data.add(pp4);
+ data.add( pattern1 );
+ data.add( r1 );
+ data.add( r2 );
+ data.add( r3 );
+ data.add( r4 );
+ data.add( i1 );
+ data.add( i2 );
+ data.add( pp1 );
+ data.add( pp2 );
- session.executeWithResults(data);
+ data.add( pattern2 );
+ data.add( r5 );
+ data.add( r6 );
+ data.add( r7 );
+ data.add( r8 );
+ data.add( i4 );
+ data.add( pp3 );
+ data.add( pp4 );
- Iterator<VerifierMessageBase> iter = result.getBySeverity(
- Severity.ERROR).iterator();
+ session.executeWithResults( data );
- boolean works = false;
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- VerifierMessage message = (VerifierMessage) o;
- if (message.getFaulty().equals(pattern1)) {
- works = true;
- } else {
- fail("There can be only one. (And this is not the one)");
- }
- }
- }
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();
- assertEquals(1, result.getBySeverity(Severity.ERROR).size());
- assertEquals(0, result.getBySeverity(Severity.WARNING).size());
- assertEquals(0, result.getBySeverity(Severity.NOTE).size());
- assertTrue(works);
- }
+ boolean works = false;
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ VerifierMessage message = (VerifierMessage) o;
+ if ( message.getFaulty().equals( pattern1 ) ) {
+ works = true;
+ } else {
+ fail( "There can be only one. (And this is not the one)" );
+ }
+ }
+ }
- public void testRules() throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Rules.drl"));
+ assertEquals( 1,
+ result.getBySeverity( Severity.ERROR ).size() );
+ assertEquals( 0,
+ result.getBySeverity( Severity.WARNING ).size() );
+ assertEquals( 0,
+ result.getBySeverity( Severity.NOTE ).size() );
+ assertTrue( works );
+ }
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Rule that is always false"));
+ /**
+ *
+ * rule "test"
+ * when
+ * TestPattern()
+ * then
+ * # Nothing
+ * end
+ *
+ * Check that a pattern with out restrictions does not raise any notifications.
+ *
+ * @throws Exception
+ */
+ public void testSinglePatternNoRestrictions() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Patterns.drl" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<Object> data = new ArrayList<Object>();
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Pattern that is always false" ) );
- session.setGlobal("result", result);
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection<Object> data = new ArrayList<Object>();
- // This rule has an error.
- VerifierRule rule1 = new VerifierRule();
+ session.setGlobal( "result",
+ result );
- PatternPossibility pp1 = new PatternPossibility();
- PatternPossibility pp2 = new PatternPossibility();
- Incompatibility i1 = new Incompatibility(pp1, pp2);
- RulePossibility rp1 = new RulePossibility();
- rp1.setRuleId(rule1.getId());
- rp1.add(pp1);
- rp1.add(pp2);
+ // This pattern has an error.
+ VerifierRule rule1 = new VerifierRule();
+ Pattern pattern1 = new Pattern();
+ pattern1.setRuleId( rule1.getId() );
- PatternPossibility pp3 = new PatternPossibility();
- PatternPossibility pp4 = new PatternPossibility();
- Incompatibility i2 = new Incompatibility(pp1, pp2);
- RulePossibility rp2 = new RulePossibility();
- rp2.setRuleId(rule1.getId());
- rp2.add(pp1);
- rp2.add(pp2);
+ data.add( rule1 );
+ data.add( pattern1 );
- // This pattern does not have an error.
- VerifierRule rule2 = new VerifierRule();
+ session.executeWithResults( data );
- PatternPossibility pp5 = new PatternPossibility();
- PatternPossibility pp6 = new PatternPossibility();
- RulePossibility rp3 = new RulePossibility();
- rp3.setRuleId(rule2.getId());
- rp3.add(pp5);
- rp3.add(pp6);
+ assertEquals( 0,
+ result.getBySeverity( Severity.ERROR ).size() );
+ assertEquals( 0,
+ result.getBySeverity( Severity.WARNING ).size() );
+ assertEquals( 0,
+ result.getBySeverity( Severity.NOTE ).size() );
+ }
- PatternPossibility pp7 = new PatternPossibility();
- PatternPossibility pp8 = new PatternPossibility();
- Incompatibility i4 = new Incompatibility(pp7, pp8);
- RulePossibility rp4 = new RulePossibility();
- rp4.setRuleId(rule2.getId());
- rp4.add(pp7);
- rp4.add(pp8);
+ public void testRules() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Rules.drl" ) );
- data.add(rule1);
- data.add(pp1);
- data.add(pp2);
- data.add(pp3);
- data.add(pp4);
- data.add(i1);
- data.add(i2);
- data.add(rp1);
- data.add(rp2);
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Rule that is always false" ) );
- data.add(rule2);
- data.add(pp5);
- data.add(pp6);
- data.add(pp7);
- data.add(pp8);
- data.add(i4);
- data.add(rp3);
- data.add(rp4);
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection<Object> data = new ArrayList<Object>();
- session.executeWithResults(data);
+ session.setGlobal( "result",
+ result );
- Iterator<VerifierMessageBase> iter = result.getBySeverity(
- Severity.ERROR).iterator();
+ // This rule has an error.
+ VerifierRule rule1 = new VerifierRule();
- boolean works = false;
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- VerifierMessage message = (VerifierMessage) o;
- if (message.getFaulty().equals(rule1)) {
- works = true;
- } else {
- fail("There can be only one. (And this is not the one)");
- }
- }
- }
+ PatternPossibility pp1 = new PatternPossibility();
+ PatternPossibility pp2 = new PatternPossibility();
+ Incompatibility i1 = new Incompatibility( pp1,
+ pp2 );
+ RulePossibility rp1 = new RulePossibility();
+ rp1.setRuleId( rule1.getId() );
+ rp1.add( pp1 );
+ rp1.add( pp2 );
- assertEquals(1, result.getBySeverity(Severity.ERROR).size());
- assertEquals(0, result.getBySeverity(Severity.WARNING).size());
- assertEquals(0, result.getBySeverity(Severity.NOTE).size());
- assertTrue(works);
- }
+ PatternPossibility pp3 = new PatternPossibility();
+ PatternPossibility pp4 = new PatternPossibility();
+ Incompatibility i2 = new Incompatibility( pp1,
+ pp2 );
+ RulePossibility rp2 = new RulePossibility();
+ rp2.setRuleId( rule1.getId() );
+ rp2.add( pp1 );
+ rp2.add( pp2 );
+
+ // This pattern does not have an error.
+ VerifierRule rule2 = new VerifierRule();
+
+ PatternPossibility pp5 = new PatternPossibility();
+ PatternPossibility pp6 = new PatternPossibility();
+ RulePossibility rp3 = new RulePossibility();
+ rp3.setRuleId( rule2.getId() );
+ rp3.add( pp5 );
+ rp3.add( pp6 );
+
+ PatternPossibility pp7 = new PatternPossibility();
+ PatternPossibility pp8 = new PatternPossibility();
+ Incompatibility i4 = new Incompatibility( pp7,
+ pp8 );
+ RulePossibility rp4 = new RulePossibility();
+ rp4.setRuleId( rule2.getId() );
+ rp4.add( pp7 );
+ rp4.add( pp8 );
+
+ data.add( rule1 );
+ data.add( pp1 );
+ data.add( pp2 );
+ data.add( pp3 );
+ data.add( pp4 );
+ data.add( i1 );
+ data.add( i2 );
+ data.add( rp1 );
+ data.add( rp2 );
+
+ data.add( rule2 );
+ data.add( pp5 );
+ data.add( pp6 );
+ data.add( pp7 );
+ data.add( pp8 );
+ data.add( i4 );
+ data.add( rp3 );
+ data.add( rp4 );
+
+ session.executeWithResults( data );
+
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();
+
+ boolean works = false;
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ VerifierMessage message = (VerifierMessage) o;
+ if ( message.getFaulty().equals( rule1 ) ) {
+ works = true;
+ } else {
+ fail( "There can be only one. (And this is not the one)" );
+ }
+ }
+ }
+
+ assertEquals( 1,
+ result.getBySeverity( Severity.ERROR ).size() );
+ assertEquals( 0,
+ result.getBySeverity( Severity.WARNING ).size() );
+ assertEquals( 0,
+ result.getBySeverity( Severity.NOTE ).size() );
+ assertTrue( works );
+ }
}
\ No newline at end of file
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 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/alwaysTrue/AlwaysTruePatternTest.java 2008-07-26 14:36:25 UTC (rev 21239)
@@ -13,6 +13,7 @@
import org.drools.verifier.components.PatternPossibility;
import org.drools.verifier.components.Restriction;
import org.drools.verifier.components.VariableRestriction;
+import org.drools.verifier.components.VerifierRule;
import org.drools.verifier.dao.VerifierResult;
import org.drools.verifier.dao.VerifierResultFactory;
import org.drools.verifier.report.components.AlwaysTrue;
@@ -28,171 +29,180 @@
*/
public class AlwaysTruePatternTest extends TestBase {
- public void testPatternPossibilities() throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Patterns.drl"));
+ public void testPatternPossibilities() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Patterns.drl" ) );
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Pattern possibility that is always true"));
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Pattern possibility that is always true" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<Object> data = new ArrayList<Object>();
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection<Object> data = new ArrayList<Object>();
- session.setGlobal("result", result);
+ session.setGlobal( "result",
+ result );
- // This pattern is always true.
- Pattern pattern1 = new Pattern();
+ // This pattern is always true.
+ Pattern pattern1 = new Pattern();
- Restriction r1 = new LiteralRestriction();
- Restriction r2 = new LiteralRestriction();
- Opposites o1 = new Opposites(r1, r2);
- PatternPossibility pp1 = new PatternPossibility();
- pp1.setPatternId(pattern1.getId());
- pp1.add(r1);
- pp1.add(r2);
+ Restriction r1 = new LiteralRestriction();
+ Restriction r2 = new LiteralRestriction();
+ Opposites o1 = new Opposites( r1,
+ r2 );
+ PatternPossibility pp1 = new PatternPossibility();
+ pp1.setPatternId( pattern1.getId() );
+ pp1.add( r1 );
+ pp1.add( r2 );
- Restriction r3 = new VariableRestriction();
- Restriction r4 = new VariableRestriction();
- Opposites o2 = new Opposites(r1, r2);
- PatternPossibility pp2 = new PatternPossibility();
- pp2.setPatternId(pattern1.getId());
- pp2.add(r1);
- pp2.add(r2);
+ Restriction r3 = new VariableRestriction();
+ Restriction r4 = new VariableRestriction();
+ Opposites o2 = new Opposites( r1,
+ r2 );
+ PatternPossibility pp2 = new PatternPossibility();
+ pp2.setPatternId( pattern1.getId() );
+ pp2.add( r1 );
+ pp2.add( r2 );
- // This pattern is okay.
- Pattern pattern2 = new Pattern();
+ // This pattern is okay.
+ Pattern pattern2 = new Pattern();
- Restriction r5 = new LiteralRestriction();
- Restriction r6 = new LiteralRestriction();
- PatternPossibility pp3 = new PatternPossibility();
- pp3.setPatternId(pattern2.getId());
- pp3.add(r5);
- pp3.add(r6);
+ Restriction r5 = new LiteralRestriction();
+ Restriction r6 = new LiteralRestriction();
+ PatternPossibility pp3 = new PatternPossibility();
+ pp3.setPatternId( pattern2.getId() );
+ pp3.add( r5 );
+ pp3.add( r6 );
- Restriction r7 = new VariableRestriction();
- Restriction r8 = new VariableRestriction();
- Opposites o4 = new Opposites(r7, r8);
- PatternPossibility pp4 = new PatternPossibility();
- pp4.setPatternId(pattern2.getId());
- pp4.add(r7);
- pp4.add(r8);
+ Restriction r7 = new VariableRestriction();
+ Restriction r8 = new VariableRestriction();
+ Opposites o4 = new Opposites( r7,
+ r8 );
+ PatternPossibility pp4 = new PatternPossibility();
+ pp4.setPatternId( pattern2.getId() );
+ pp4.add( r7 );
+ pp4.add( r8 );
- data.add(pattern1);
- data.add(r1);
- data.add(r2);
- data.add(r3);
- data.add(r4);
- data.add(o1);
- data.add(o2);
- data.add(pp1);
- data.add(pp2);
+ data.add( pattern1 );
+ data.add( r1 );
+ data.add( r2 );
+ data.add( r3 );
+ data.add( r4 );
+ data.add( o1 );
+ data.add( o2 );
+ data.add( pp1 );
+ data.add( pp2 );
- data.add(pattern2);
- data.add(r5);
- data.add(r6);
- data.add(r7);
- data.add(r8);
- data.add(o4);
- data.add(pp3);
- data.add(pp4);
+ data.add( pattern2 );
+ data.add( r5 );
+ data.add( r6 );
+ data.add( r7 );
+ data.add( r8 );
+ data.add( o4 );
+ data.add( pp3 );
+ data.add( pp4 );
- StatelessSessionResult sessionResult = session.executeWithResults(data);
- Iterator iter = sessionResult.iterateObjects();
+ StatelessSessionResult sessionResult = session.executeWithResults( data );
+ Iterator iter = sessionResult.iterateObjects();
- boolean pp1true = false;
- boolean pp2true = false;
- boolean pp3true = false;
- boolean pp4true = false;
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof AlwaysTrue) {
- AlwaysTrue alwaysTrue = (AlwaysTrue) o;
- if (!pp1true) {
- pp1true = alwaysTrue.getCause().equals(pp1);
- }
- if (!pp2true) {
- pp2true = alwaysTrue.getCause().equals(pp2);
- }
- if (!pp3true) {
- pp3true = alwaysTrue.getCause().equals(pp3);
- }
- if (!pp4true) {
- pp4true = alwaysTrue.getCause().equals(pp4);
- }
- }
- }
+ boolean pp1true = false;
+ boolean pp2true = false;
+ boolean pp3true = false;
+ boolean pp4true = false;
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof AlwaysTrue ) {
+ AlwaysTrue alwaysTrue = (AlwaysTrue) o;
+ if ( !pp1true ) {
+ pp1true = alwaysTrue.getCause().equals( pp1 );
+ }
+ if ( !pp2true ) {
+ pp2true = alwaysTrue.getCause().equals( pp2 );
+ }
+ if ( !pp3true ) {
+ pp3true = alwaysTrue.getCause().equals( pp3 );
+ }
+ if ( !pp4true ) {
+ pp4true = alwaysTrue.getCause().equals( pp4 );
+ }
+ }
+ }
- assertTrue(pp1true);
- assertTrue(pp2true);
- assertFalse(pp3true);
- assertTrue(pp4true);
- }
+ assertTrue( pp1true );
+ assertTrue( pp2true );
+ assertFalse( pp3true );
+ assertTrue( pp4true );
+ }
- public void testPatterns() throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Patterns.drl"));
+ public void testPatterns() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Patterns.drl" ) );
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Pattern that is always true"));
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Pattern that is always true" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<Object> data = new ArrayList<Object>();
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection<Object> data = new ArrayList<Object>();
- session.setGlobal("result", result);
+ session.setGlobal( "result",
+ result );
- // This pattern is always true.
- Pattern pattern1 = new Pattern();
+ VerifierRule rule1 = new VerifierRule();
- PatternPossibility pp1 = new PatternPossibility();
- pp1.setPatternId(pattern1.getId());
- AlwaysTrue alwaysTrue1 = new AlwaysTrue(pp1);
+ // This pattern is always true.
+ Pattern pattern1 = new Pattern();
+ pattern1.setRuleId( rule1.getId() );
- PatternPossibility pp2 = new PatternPossibility();
- pp2.setPatternId(pattern1.getId());
- AlwaysTrue alwaysTrue2 = new AlwaysTrue(pp2);
+ PatternPossibility pp1 = new PatternPossibility();
+ pp1.setPatternId( pattern1.getId() );
+ AlwaysTrue alwaysTrue1 = new AlwaysTrue( pp1 );
- // This pattern is okay.
- Pattern pattern2 = new Pattern();
+ PatternPossibility pp2 = new PatternPossibility();
+ pp2.setPatternId( pattern1.getId() );
+ AlwaysTrue alwaysTrue2 = new AlwaysTrue( pp2 );
- PatternPossibility pp3 = new PatternPossibility();
- pp3.setPatternId(pattern2.getId());
+ // This pattern is okay.
+ Pattern pattern2 = new Pattern();
+ pattern2.setRuleId( rule1.getId() );
- PatternPossibility pp4 = new PatternPossibility();
- pp4.setPatternId(pattern2.getId());
- AlwaysTrue alwaysTrue4 = new AlwaysTrue(pp4);
+ PatternPossibility pp3 = new PatternPossibility();
+ pp3.setPatternId( pattern2.getId() );
- data.add(pattern1);
- data.add(pp1);
- data.add(pp2);
- data.add(alwaysTrue1);
- data.add(alwaysTrue2);
+ PatternPossibility pp4 = new PatternPossibility();
+ pp4.setPatternId( pattern2.getId() );
+ AlwaysTrue alwaysTrue4 = new AlwaysTrue( pp4 );
- data.add(pattern2);
- data.add(pp3);
- data.add(pp4);
- data.add(alwaysTrue4);
+ data.add( rule1 );
- session.executeWithResults(data);
+ data.add( pattern1 );
+ data.add( pp1 );
+ data.add( pp2 );
+ data.add( alwaysTrue1 );
+ data.add( alwaysTrue2 );
- Iterator<VerifierMessageBase> iter = result
- .getBySeverity(Severity.NOTE).iterator();
+ data.add( pattern2 );
+ data.add( pp3 );
+ data.add( pp4 );
+ data.add( alwaysTrue4 );
- boolean works = false;
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- VerifierMessage message = (VerifierMessage) o;
- if (message.getFaulty().equals(pattern1)) {
- works = true;
- } else {
- fail("There can be only one. (And this is not the one)");
- }
- }
- }
+ session.executeWithResults( data );
- assertEquals(0, result.getBySeverity(Severity.ERROR).size());
- assertEquals(0, result.getBySeverity(Severity.WARNING).size());
- assertEquals(1, result.getBySeverity(Severity.NOTE).size());
- assertTrue(works);
- }
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.NOTE ).iterator();
+
+ boolean works = false;
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ VerifierMessage message = (VerifierMessage) o;
+ if ( message.getFaulty().equals( pattern1 ) ) {
+ works = true;
+ } else {
+ fail( "There can be only one. (And this is not the one)" );
+ }
+ }
+ }
+
+ assertEquals( 0,
+ result.getBySeverity( Severity.ERROR ).size() );
+ assertEquals( 0,
+ result.getBySeverity( Severity.WARNING ).size() );
+ assertEquals( 1,
+ result.getBySeverity( Severity.NOTE ).size() );
+ assertTrue( works );
+ }
}
\ No newline at end of file
Modified: labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incoherence/IncoherentRestrictionsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incoherence/IncoherentRestrictionsTest.java 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/test/java/org/drools/verifier/incoherence/IncoherentRestrictionsTest.java 2008-07-26 14:36:25 UTC (rev 21239)
@@ -22,278 +22,245 @@
*/
public class IncoherentRestrictionsTest extends TestBase {
- public void testIncoherentLiteralRestrictionsInPatternPossibility()
- throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Restrictions.drl"));
+ public void testIncoherentLiteralRestrictionsInPatternPossibility() throws Exception {
+ StatelessSession session = getStatelessSession( getClass().getResourceAsStream( "Restrictions.drl" ) );
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Incoherent LiteralRestrictions in pattern possibility"));
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent LiteralRestrictions in pattern possibility" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<? extends Object> testData = getTestData(this.getClass()
- .getResourceAsStream("RestrictionsTest.drl"), result
- .getVerifierData());
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection< ? extends Object> testData = getTestData( getClass().getResourceAsStream( "RestrictionsTest.drl" ),
+ result.getVerifierData() );
- session.setGlobal("result", result);
+ session.setGlobal( "result",
+ result );
- session.executeWithResults(testData);
+ session.executeWithResults( testData );
- Iterator<VerifierMessageBase> iter = result.getBySeverity(
- Severity.ERROR).iterator();
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();
- Set<String> rulesThatHadErrors = new HashSet<String>();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
- rulesThatHadErrors.add(pattern.getRuleName());
- }
- }
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
+ rulesThatHadErrors.add( pattern.getRuleName() );
+ }
+ }
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 1"));
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 2"));
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 1" ) );
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 2" ) );
- if (!rulesThatHadErrors.isEmpty()) {
- for (String string : rulesThatHadErrors) {
- fail("Rule " + string + " caused an error.");
- }
- }
- }
+ if ( !rulesThatHadErrors.isEmpty() ) {
+ for ( String string : rulesThatHadErrors ) {
+ fail( "Rule " + string + " caused an error." );
+ }
+ }
+ }
- public void testIncoherentLiteralRestrictionsInPatternPossibilityImpossibleRanges()
- throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Restrictions.drl"));
+ public void testIncoherentLiteralRestrictionsInPatternPossibilityImpossibleRanges() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );
- session
- .setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible ranges"));
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible ranges" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<? extends Object> testData = getTestData(this.getClass()
- .getResourceAsStream("RestrictionsTest.drl"), result
- .getVerifierData());
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
+ result.getVerifierData() );
- session.setGlobal("result", result);
+ session.setGlobal( "result",
+ result );
- session.executeWithResults(testData);
+ session.executeWithResults( testData );
- Iterator<VerifierMessageBase> iter = result.getBySeverity(
- Severity.ERROR).iterator();
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();
- Set<String> rulesThatHadErrors = new HashSet<String>();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
- rulesThatHadErrors.add(pattern.getRuleName());
- }
- }
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
+ rulesThatHadErrors.add( pattern.getRuleName() );
+ }
+ }
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 8"));
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 8" ) );
- if (!rulesThatHadErrors.isEmpty()) {
- for (String string : rulesThatHadErrors) {
- fail("Rule " + string + " caused an error.");
- }
- }
- }
+ if ( !rulesThatHadErrors.isEmpty() ) {
+ for ( String string : rulesThatHadErrors ) {
+ fail( "Rule " + string + " caused an error." );
+ }
+ }
+ }
- public void testIncoherentLiteralRestrictionsInPatternPossibilityImpossibleEqualityLess()
- throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Restrictions.drl"));
+ public void testIncoherentLiteralRestrictionsInPatternPossibilityImpossibleEqualityLess() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );
- session
- .setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible equality less or equal"));
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible equality less or equal" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<? extends Object> testData = getTestData(this.getClass()
- .getResourceAsStream("RestrictionsTest.drl"), result
- .getVerifierData());
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
+ result.getVerifierData() );
- session.setGlobal("result", result);
+ session.setGlobal( "result",
+ result );
- session.executeWithResults(testData);
+ session.executeWithResults( testData );
- Iterator<VerifierMessageBase> iter = result.getBySeverity(
- Severity.ERROR).iterator();
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();
- Set<String> rulesThatHadErrors = new HashSet<String>();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
- rulesThatHadErrors.add(pattern.getRuleName());
- }
- }
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
+ rulesThatHadErrors.add( pattern.getRuleName() );
+ }
+ }
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 9"));
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 11"));
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 9" ) );
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 11" ) );
- if (!rulesThatHadErrors.isEmpty()) {
- for (String string : rulesThatHadErrors) {
- fail("Rule " + string + " caused an error.");
- }
- }
- }
+ if ( !rulesThatHadErrors.isEmpty() ) {
+ for ( String string : rulesThatHadErrors ) {
+ fail( "Rule " + string + " caused an error." );
+ }
+ }
+ }
- public void testIncoherentLiteralRestrictionsInPatternPossibilityImpossibleEqualityGreater()
- throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Restrictions.drl"));
+ public void testIncoherentLiteralRestrictionsInPatternPossibilityImpossibleEqualityGreater() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );
- session
- .setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible equality greater"));
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible equality greater" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<? extends Object> testData = getTestData(this.getClass()
- .getResourceAsStream("RestrictionsTest.drl"), result
- .getVerifierData());
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
+ result.getVerifierData() );
- session.setGlobal("result", result);
+ session.setGlobal( "result",
+ result );
- session.executeWithResults(testData);
+ session.executeWithResults( testData );
- Iterator<VerifierMessageBase> iter = result.getBySeverity(
- Severity.ERROR).iterator();
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();
- Set<String> rulesThatHadErrors = new HashSet<String>();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
- rulesThatHadErrors.add(pattern.getRuleName());
- }
- }
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
+ rulesThatHadErrors.add( pattern.getRuleName() );
+ }
+ }
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 10"));
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 10" ) );
- if (!rulesThatHadErrors.isEmpty()) {
- for (String string : rulesThatHadErrors) {
- fail("Rule " + string + " caused an error.");
- }
- }
- }
+ if ( !rulesThatHadErrors.isEmpty() ) {
+ for ( String string : rulesThatHadErrors ) {
+ fail( "Rule " + string + " caused an error." );
+ }
+ }
+ }
- public void testIncoherentLiteralRestrictionsInPatternPossibilityImpossibleRange()
- throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Restrictions.drl"));
+ public void testIncoherentLiteralRestrictionsInPatternPossibilityImpossibleRange() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );
- session
- .setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible range"));
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible range" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<? extends Object> testData = getTestData(this.getClass()
- .getResourceAsStream("RestrictionsTest.drl"), result
- .getVerifierData());
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
+ result.getVerifierData() );
- session.setGlobal("result", result);
+ session.setGlobal( "result",
+ result );
- session.executeWithResults(testData);
+ session.executeWithResults( testData );
- Iterator<VerifierMessageBase> iter = result.getBySeverity(
- Severity.ERROR).iterator();
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();
- Set<String> rulesThatHadErrors = new HashSet<String>();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
- rulesThatHadErrors.add(pattern.getRuleName());
- }
- }
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
+ rulesThatHadErrors.add( pattern.getRuleName() );
+ }
+ }
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 7"));
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 7" ) );
- if (!rulesThatHadErrors.isEmpty()) {
- for (String string : rulesThatHadErrors) {
- fail("Rule " + string + " caused an error.");
- }
- }
- }
+ if ( !rulesThatHadErrors.isEmpty() ) {
+ for ( String string : rulesThatHadErrors ) {
+ fail( "Rule " + string + " caused an error." );
+ }
+ }
+ }
- public void testIncoherentVariableRestrictionsInPatternPossibility()
- throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Restrictions.drl"));
+ public void testIncoherentVariableRestrictionsInPatternPossibility() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Incoherent VariableRestrictions in pattern possibility"));
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent VariableRestrictions in pattern possibility" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<? extends Object> testData = getTestData(this.getClass()
- .getResourceAsStream("RestrictionsTest.drl"), result
- .getVerifierData());
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
+ result.getVerifierData() );
- session.setGlobal("result", result);
+ session.setGlobal( "result",
+ result );
- session.executeWithResults(testData);
+ session.executeWithResults( testData );
- Iterator<VerifierMessageBase> iter = result.getBySeverity(
- Severity.ERROR).iterator();
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();
- Set<String> rulesThatHadErrors = new HashSet<String>();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
- rulesThatHadErrors.add(pattern.getRuleName());
- }
- }
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
+ rulesThatHadErrors.add( pattern.getRuleName() );
+ }
+ }
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 3"));
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 4"));
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 5"));
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 3" ) );
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 4" ) );
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 5" ) );
- if (!rulesThatHadErrors.isEmpty()) {
- for (String string : rulesThatHadErrors) {
- fail("Rule " + string + " caused an error.");
- }
- }
- }
+ if ( !rulesThatHadErrors.isEmpty() ) {
+ for ( String string : rulesThatHadErrors ) {
+ fail( "Rule " + string + " caused an error." );
+ }
+ }
+ }
- public void testIncoherentVariableRestrictionsInPatternPossibilityImpossibleRange()
- throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("Restrictions.drl"));
+ public void testIncoherentVariableRestrictionsInPatternPossibilityImpossibleRange() throws Exception {
+ StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );
- session
- .setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Incoherent VariableRestrictions in pattern possibility, impossible range"));
+ session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent VariableRestrictions in pattern possibility, impossible range" ) );
- VerifierResult result = VerifierResultFactory.createVerifierResult();
- Collection<? extends Object> testData = getTestData(this.getClass()
- .getResourceAsStream("RestrictionsTest.drl"), result
- .getVerifierData());
+ VerifierResult result = VerifierResultFactory.createVerifierResult();
+ Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
+ result.getVerifierData() );
- session.setGlobal("result", result);
+ session.setGlobal( "result",
+ result );
- session.executeWithResults(testData);
+ session.executeWithResults( testData );
- Iterator<VerifierMessageBase> iter = result.getBySeverity(
- Severity.ERROR).iterator();
+ Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();
- Set<String> rulesThatHadErrors = new HashSet<String>();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof VerifierMessage) {
- Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
- rulesThatHadErrors.add(pattern.getRuleName());
- }
- }
+ Set<String> rulesThatHadErrors = new HashSet<String>();
+ while ( iter.hasNext() ) {
+ Object o = (Object) iter.next();
+ if ( o instanceof VerifierMessage ) {
+ Pattern pattern = (Pattern) ((VerifierMessage) o).getFaulty();
+ rulesThatHadErrors.add( pattern.getRuleName() );
+ }
+ }
- assertTrue(rulesThatHadErrors.remove("Incoherent restrictions 6"));
+ assertTrue( rulesThatHadErrors.remove( "Incoherent restrictions 6" ) );
- if (!rulesThatHadErrors.isEmpty()) {
- for (String string : rulesThatHadErrors) {
- fail("Rule " + string + " caused an error.");
- }
- }
- }
+ if ( !rulesThatHadErrors.isEmpty() ) {
+ for ( String string : rulesThatHadErrors ) {
+ fail( "Rule " + string + " caused an error." );
+ }
+ }
+ }
}
\ No newline at end of file
Modified: labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/Enums.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/Enums.drl 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/Enums.drl 2008-07-26 14:36:25 UTC (rev 21239)
@@ -9,110 +9,4 @@
count : Count()
then
#
-end
-
-/*
-rule assignFirstSeat
- when
- context : Context( state == Context.START_UP )
- guest : Guest()
- count : Count()
- then
- String guestName = guest.getName();
-
- Seating seating = new Seating( count.getValue(), 1, true, 1, guestName, 1, guestName);
- insert( seating );
-
- Path path = new Path( count.getValue(), 1, guestName );
- insert( path );
-
- modify( count ) { setValue ( count.getValue() + 1 ) }
-
- System.out.println( "assign first seat : " + seating + " : " + path );
-
- modify( context ) {
- setState( Context.ASSIGN_SEATS )
- }
-end
-
-rule findSeating
- when
- context : Context( state == Context.ASSIGN_SEATS )
- $s : Seating( pathDone == true )
- $g1 : Guest( name == $s.rightGuestName )
- $g2 : Guest( sex != $g1.sex, hobby == $g1.hobby )
-
- count : Count()
-
- not ( Path( id == $s.id, guestName == $g2.name) )
- not ( Chosen( id == $s.id, guestName == $g2.name, hobby == $g1.hobby) )
- then
- int rightSeat = $s.getRightSeat();
- int seatId = $s.getId();
- int countValue = count.getValue();
-
- Seating seating = new Seating( countValue, seatId, false, rightSeat, $s.getRightGuestName(), rightSeat + 1, $g2.getName() );
- insert( seating );
-
- Path path = new Path( countValue, rightSeat + 1, $g2.getName() );
- insert( path );
-
- Chosen chosen = new Chosen( seatId, $g2.getName(), $g1.getHobby() );
- insert( chosen );
-
- System.err.println( "find seating : " + seating + " : " + path + " : " + chosen);
-
- modify( count ) {setValue( countValue + 1 )}
- modify( context ) {setState( Context.MAKE_PATH )}
-end
-
-rule makePath
- when
- Context( state == Context.MAKE_PATH )
- Seating( seatingId:id, seatingPid:pid, pathDone == false )
- Path( id == seatingPid, pathGuestName:guestName, pathSeat:seat )
- not Path( id == seatingId, guestName == pathGuestName )
- then
- insert( new Path( seatingId, pathSeat, pathGuestName ) );
-end
-
-rule pathDone
- when
- context : Context( state == Context.MAKE_PATH )
- seating : Seating( pathDone == false )
- then
- modify( seating ) {setPathDone( true )}
-
- modify( context ) {setState( Context.CHECK_DONE)}
-end
-
-
-rule areWeDone
- when
- context : Context( state == Context.CHECK_DONE )
- LastSeat( lastSeat: seat )
- Seating( rightSeat == lastSeat )
- then
- modify( context ) {setState(Context.PRINT_RESULTS )}
-end
-
-rule continue
- when
- context : Context( state == Context.CHECK_DONE )
- then
- modify( context ) {setState( Context.ASSIGN_SEATS )}
-end
-
-
-rule allDone
- when
- context : Context( state == Context.PRINT_RESULTS )
- then
- System.out.println( "All Done" );
-end
-*/
-
-//query getResults
-// context : Context( state == Context.PRINT_RESULTS )
-//end
-
\ No newline at end of file
+end
\ No newline at end of file
Modified: labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/incoherence/RestrictionsTest.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/incoherence/RestrictionsTest.drl 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/incoherence/RestrictionsTest.drl 2008-07-26 14:36:25 UTC (rev 21239)
@@ -20,17 +20,19 @@
# Test
end
+
rule "Incoherent restrictions 3"
when
- $o :Object
+ $o :Object()
IncoherencePattern3( a contains $o, a not contains $o )
then
# Test
end
+
rule "Incoherent restrictions 4"
when
- $list :ListItem
+ $list :ListItem()
IncoherencePattern4( a memberOf $list, a not memberOf $list )
then
# Test
@@ -38,7 +40,7 @@
rule "Incoherent restrictions 5"
when
- $var :Object
+ $var :Object()
IncoherencePattern5( a == $var, a != $var )
then
# Test
@@ -46,7 +48,7 @@
rule "Incoherent restrictions 6"
when
- $var :Object
+ $var :Object()
IncoherencePattern6( a > $var, a < $var )
then
# Test
@@ -96,4 +98,4 @@
order : OrderHeader( customer == customer , orderPriority == "3" || == "4" )
then
order.setOrderDiscount( 6.0 );
-end
\ No newline at end of file
+end
Modified: labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/optimisation/OptimisationPatternOrderTest.drl
===================================================================
--- labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/optimisation/OptimisationPatternOrderTest.drl 2008-07-26 14:21:24 UTC (rev 21238)
+++ labs/jbossrules/trunk/drools-verifier/src/test/resources/org/drools/verifier/optimisation/OptimisationPatternOrderTest.drl 2008-07-26 14:36:25 UTC (rev 21239)
@@ -4,7 +4,7 @@
rule "Correct eval order 1"
when
- Foo( )
+ Foo()
eval( func(1, 2) )
then
// Something
@@ -13,7 +13,7 @@
rule "Wrong eval order 1"
when
eval( func(1, 2) )
- Foo( )
+ Foo()
then
// Something
-end
\ No newline at end of file
+end
More information about the jboss-svn-commits
mailing list