[jboss-svn-commits] JBL Code SVN: r18110 - in labs/jbossrules/trunk/drools-analytics/src: main/resources/org/drools/analytics/subsumption and 2 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Fri Jan 25 09:19:39 EST 2008
Author: Rikkola
Date: 2008-01-25 09:19:38 -0500 (Fri, 25 Jan 2008)
New Revision: 18110
Added:
labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/subsumption/
labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/subsumption/Possibilities.drl
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/subsumption/
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/subsumption/SubsumptantPossibilitiesTest.java
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/subsumption/SubsumptionTestBase.java
Log:
The unit test that gives an error for tirelli. Test name is org.drools.analytics.subsumption.SubsumptionPossibilitiesTest.FIXMEtestRulePossibilityRedundancy
Added: labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/subsumption/Possibilities.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/subsumption/Possibilities.drl (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/subsumption/Possibilities.drl 2008-01-25 14:19:38 UTC (rev 18110)
@@ -0,0 +1,194 @@
+#created on: 8.1.2008
+package org.drools.analytics.subsumption.patterns
+
+import org.drools.analytics.components.Restriction;
+import org.drools.analytics.components.Pattern;
+import org.drools.analytics.components.PatternPossibility;
+import org.drools.analytics.components.RulePossibility;
+import org.drools.analytics.report.components.Redundancy;
+import org.drools.analytics.report.components.Subsumption;
+import org.drools.analytics.report.components.CauseType;
+import org.drools.analytics.report.components.RedundancyType;
+
+
+#declare any global variables here
+
+
+#
+# Finds subsumptant patterns possibilities
+#
+# Depandencies: TODO: Dependencies
+#
+rule "Find subsumptant pattern possibilities"
+ when
+ $redundancy :Redundancy(
+ left.causeType == CauseType.PATTERN
+ )
+
+ # Find two PatternPossibilities.
+ (
+ $pp1 :PatternPossibility(
+ eval( patternId == $redundancy.getLeft().getId() )
+ )
+ and
+ $pp2 :PatternPossibility(
+ eval( patternId == $redundancy.getRight().getId() )
+ )
+ ) or (
+ $pp1 :PatternPossibility(
+ eval( patternId == $redundancy.getRight().getId() )
+ )
+ and
+ $pp2 :PatternPossibility(
+ eval( patternId == $redundancy.getLeft().getId() )
+ )
+ )
+
+ # For every restriction in $pp1 there is a redundancy to restriction in $pp2.
+ forall(
+ $r :Restriction(
+ patternId == $pp1.patternId,
+ this memberOf $pp1.items
+ )
+
+ Redundancy(
+ (
+ left == $r
+ &&
+ right memberOf $pp2.items
+ ) || (
+ left memberOf $pp2.items
+ &&
+ right == $r
+ )
+ )
+ )
+
+ # There is at least one restriction in $pp2 that has a redundancy to restriction in $pp1.
+ exists(
+ $r :Restriction(
+ patternId == $pp2.patternId,
+ this memberOf $pp2.items
+ )
+ and
+ Redundancy(
+ (
+ left == $r
+ &&
+ right memberOf $pp1.items
+ ) || (
+ left memberOf $pp1.items
+ &&
+ right == $r
+ )
+ )
+ )
+
+ # There is at least one restriction in $pp2 that does not hava a redundancy to restriction in $pp1.
+ not(
+ $r :Restriction(
+ patternId == $pp2.patternId,
+ this memberOf $pp2.items
+ )
+ and
+ forall (
+ Redundancy(
+ (
+ left == $r
+ &&
+ right memberOf $pp1.items
+ ) || (
+ left memberOf $pp1.items
+ &&
+ right == $r
+ )
+ )
+ )
+ )
+
+ then
+ insert( new Subsumption( $pp1, $pp2 ) );
+end
+
+#
+# Finds subsumptant rule possibilities
+#
+# Depandencies: TODO: Dependencies
+#
+rule "Find subsumptant rule possibilities"
+ when
+ $redundancy :Redundancy(
+ left.causeType == CauseType.RULE,
+ $leftRuleId :left.id,
+ $rightRuleId :right.id
+ )
+
+ # Find two RulePossibilities.
+ $rp1 :RulePossibility(
+ ruleId == $leftRuleId
+ )
+ $rp2 :RulePossibility(
+ ruleId == $rightRuleId
+ )
+
+ # For every pattern possibility in $rp1 there is a redundant pattern possibility in $rp2.
+ forall(
+ $pp :PatternPossibility(
+ ruleId == $rp1.ruleId,
+ this memberOf $rp1.items
+ )
+
+# Redundancy(
+# type == RedundancyType.STRONG,
+# left == $pp,
+# right memberOf $rp2.items
+# )
+ )
+
+ # There is at least one PatternPossibility in $rp2 that does not hava a redundancy to PatternPossibility in $rp1.
+
+ #$pp :PatternPossibility(
+ # ruleId == $rp2.ruleId,
+ # this memberOf $rp2.items
+ #)
+ exists(
+ Subsumption(
+# left memberOf $rp2.items,
+# right memberOf $rp1.items
+ )
+ or
+ Redundancy(
+# type == RedundancyType.STRONG,
+# left memberOf $rp2.items,
+# right memberOf $rp1.items
+ )
+ )
+
+ # There is at least one PatternPossibility in $rp2 that does not hava a redundancy to PatternPossibility in $rp1.
+ #not(
+ # $pp :PatternPossibility(
+ # ruleId == $rp2.ruleId,
+ # this memberOf $rp2.items
+ # )
+ # and
+ # forall (
+ # Redundancy(
+ # type == RedundancyType.STRONG,
+ # (
+ # left == $pp
+ # &&
+ # right memberOf $rp1.items
+ # ) || (
+ # left memberOf $rp1.items
+ # &&
+ # right == $pp
+ # )
+ # )
+ # )
+ #)
+
+ then
+ System.out.println("pim");
+ #insert( new Subsumption( $rp1, $rp2 ) );
+end
+
Added: labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/subsumption/SubsumptantPossibilitiesTest.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/subsumption/SubsumptantPossibilitiesTest.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/subsumption/SubsumptantPossibilitiesTest.java 2008-01-25 14:19:38 UTC (rev 18110)
@@ -0,0 +1,160 @@
+package org.drools.analytics.subsumption;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import org.drools.StatelessSession;
+import org.drools.StatelessSessionResult;
+import org.drools.analytics.TestBase;
+import org.drools.analytics.components.AnalyticsRule;
+import org.drools.analytics.components.LiteralRestriction;
+import org.drools.analytics.components.Pattern;
+import org.drools.analytics.components.PatternPossibility;
+import org.drools.analytics.components.RulePossibility;
+import org.drools.analytics.dao.AnalyticsResult;
+import org.drools.analytics.dao.AnalyticsResultFactory;
+import org.drools.analytics.report.components.Cause;
+import org.drools.analytics.report.components.CauseType;
+import org.drools.analytics.report.components.Redundancy;
+import org.drools.analytics.report.components.RedundancyType;
+import org.drools.base.RuleNameMatchesAgendaFilter;
+
+public class SubsumptantPossibilitiesTest extends SubsumptionTestBase {
+
+ public void FIXMEtestPatternPossibilityRedundancy() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Possibilities.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Find subsumptant pattern possibilities"));
+
+ Collection<Object> data = new ArrayList<Object>();
+
+ AnalyticsResult result = AnalyticsResultFactory.createAnalyticsResult();
+ session.setGlobal("result", result);
+
+ String ruleName1 = "Rule 1";
+ String ruleName2 = "Rule 2";
+
+ Pattern p1 = new Pattern();
+ p1.setRuleName(ruleName1);
+ Pattern p2 = new Pattern();
+ p2.setRuleName(ruleName2);
+
+ LiteralRestriction lr1 = new LiteralRestriction();
+ lr1.setRuleName(ruleName1);
+ LiteralRestriction lr2 = new LiteralRestriction();
+ lr2.setRuleName(ruleName2);
+ LiteralRestriction lr3 = new LiteralRestriction();
+ lr2.setRuleName(ruleName2);
+
+ PatternPossibility pp1 = new PatternPossibility();
+ pp1.setPatternId(p1.getId());
+ pp1.setRuleName(ruleName1);
+ pp1.add(lr1);
+
+ PatternPossibility pp2 = new PatternPossibility();
+ pp2.setPatternId(p2.getId());
+ pp2.setRuleName(ruleName2);
+ pp2.add(lr2);
+ pp2.add(lr3);
+
+ Redundancy r1 = new Redundancy(lr1, lr2);
+ Redundancy r2 = new Redundancy(p1, p2);
+
+ data.add(p1);
+ data.add(p2);
+ data.add(lr1);
+ data.add(lr2);
+ data.add(lr3);
+ data.add(pp1);
+ data.add(pp2);
+ data.add(r1);
+ data.add(r2);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<String, Set<String>> map = createSubsumptionMap(sessionResult
+ .iterateObjects());
+
+ assertTrue(TestBase.mapContains(map, ruleName2, ruleName1));
+
+ if (!map.isEmpty()) {
+ fail("More redundancies than was expected.");
+ }
+ }
+
+ /**
+ * The problem is in this test -Rikkola-
+ *
+ * @throws Exception
+ */
+ public void FIXMEtestRulePossibilityRedundancy() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Possibilities.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Find subsumptant rule possibilities"));
+
+ Collection<Object> data = new ArrayList<Object>();
+
+ AnalyticsResult result = AnalyticsResultFactory.createAnalyticsResult();
+ session.setGlobal("result", result);
+
+ /*
+ * First rules. These are subsumptant,
+ */
+ String ruleName1 = "Rule 1";
+ String ruleName2 = "Rule 2";
+
+ AnalyticsRule r1 = new AnalyticsRule();
+ r1.setRuleName(ruleName1);
+ AnalyticsRule r2 = new AnalyticsRule();
+ r2.setRuleName(ruleName2);
+
+ PatternPossibility pp1 = new PatternPossibility();
+ pp1.setRuleName(ruleName1);
+ PatternPossibility pp2 = new PatternPossibility();
+ pp2.setRuleName(ruleName2);
+ PatternPossibility pp3 = new PatternPossibility();
+ pp3.setRuleName(ruleName2);
+
+ RulePossibility rp1 = new RulePossibility();
+ rp1.setRuleId(r1.getId());
+ rp1.setRuleName(ruleName1);
+ rp1.add(pp1);
+
+ RulePossibility rp2 = new RulePossibility();
+ rp2.setRuleId(r2.getId());
+ rp2.setRuleName(ruleName2);
+ rp2.add(pp2);
+ rp2.add(pp3);
+
+ Redundancy possibilityredundancy = new Redundancy(
+ RedundancyType.STRONG, pp1, pp2);
+ Redundancy ruleRedundancy = new Redundancy(r1, r2);
+
+ data.add(r1);
+ data.add(r2);
+ data.add(pp1);
+ data.add(pp2);
+ data.add(pp3);
+ data.add(possibilityredundancy);
+ data.add(ruleRedundancy);
+ data.add(rp1);
+ data.add(rp2);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<String, Set<String>> map = createSubsumptionMap(sessionResult
+ .iterateObjects());
+
+ assertTrue(TestBase.mapContains(map, ruleName2, ruleName1));
+
+ if (!map.isEmpty()) {
+ fail("More redundancies than was expected.");
+ }
+ }
+}
Added: labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/subsumption/SubsumptionTestBase.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/subsumption/SubsumptionTestBase.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/subsumption/SubsumptionTestBase.java 2008-01-25 14:19:38 UTC (rev 18110)
@@ -0,0 +1,56 @@
+package org.drools.analytics.subsumption;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import org.drools.analytics.TestBase;
+import org.drools.analytics.components.AnalyticsComponent;
+import org.drools.analytics.report.components.Subsumption;
+
+/**
+ *
+ * @author Toni Rikkola
+ *
+ */
+public class SubsumptionTestBase extends TestBase {
+
+ public void testDummy() {
+ // this is needed as eclipse will try to run this and produce a failure
+ // if its not here.
+ }
+
+ /**
+ * Creates subsumption map from Subsumption objects, one rule may have
+ * several subsumption dependencies.
+ *
+ * @param iter
+ * @return
+ */
+ protected Map<String, Set<String>> createSubsumptionMap(
+ Iterator<Object> iter) {
+
+ Map<String, Set<String>> map = new HashMap<String, Set<String>>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Subsumption) {
+ Subsumption s = (Subsumption) o;
+ AnalyticsComponent left = (AnalyticsComponent) s.getLeft();
+ AnalyticsComponent right = (AnalyticsComponent) s.getRight();
+
+ if (map.containsKey(left.getRuleName())) {
+ Set<String> set = map.get(left.getRuleName());
+ set.add(right.getRuleName());
+ } else {
+ Set<String> set = new HashSet<String>();
+ set.add(right.getRuleName());
+ map.put(left.getRuleName(), set);
+ }
+ }
+ }
+
+ return map;
+ }
+}
More information about the jboss-svn-commits
mailing list