[jboss-svn-commits] JBL Code SVN: r16750 - in labs/jbossrules/trunk/drools-analytics/src: test/java/org/drools/analytics and 3 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Thu Nov 22 09:14:32 EST 2007
Author: Rikkola
Date: 2007-11-22 09:14:32 -0500 (Thu, 22 Nov 2007)
New Revision: 16750
Added:
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Consquence.java
labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/TextConsequence.java
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/redundancy/RedundancyTest.java
labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/redundancy/
labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/redundancy/PatternRedundancyTest.drl
Removed:
labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/RedundancyTest.java
labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/PatternRedundancyTest.drl
Log:
Consequence classes and redundancy fix.
Added: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Consquence.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Consquence.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/Consquence.java 2007-11-22 14:14:32 UTC (rev 16750)
@@ -0,0 +1,17 @@
+package org.drools.analytics.components;
+
+public interface Consquence {
+
+ public static enum ConsequenceType {
+ TEXT
+ }
+
+ public int getId();
+
+ public ConsequenceType getConsequenceType();
+
+ public int getRuleId();
+
+ public String getRuleName();
+
+}
Added: labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/TextConsequence.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/TextConsequence.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/main/java/org/drools/analytics/components/TextConsequence.java 2007-11-22 14:14:32 UTC (rev 16750)
@@ -0,0 +1,28 @@
+package org.drools.analytics.components;
+
+public class TextConsequence extends AnalyticsComponent implements Consquence {
+
+ private static int index = 0;
+ private String text;
+
+ public TextConsequence() {
+ super(index++);
+ }
+
+ public ConsequenceType getConsequenceType() {
+ return ConsequenceType.TEXT;
+ }
+
+ @Override
+ public AnalyticsComponentType getComponentType() {
+ return AnalyticsComponentType.CONSEQUENCE;
+ }
+
+ public void setText(String text) {
+ this.text = text;
+ }
+
+ public String getText() {
+ return text;
+ }
+}
Deleted: labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/RedundancyTest.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/RedundancyTest.java 2007-11-22 13:16:13 UTC (rev 16749)
+++ labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/RedundancyTest.java 2007-11-22 14:14:32 UTC (rev 16750)
@@ -1,434 +0,0 @@
-package org.drools.analytics;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-
-import org.drools.StatelessSession;
-import org.drools.StatelessSessionResult;
-import org.drools.analytics.components.AnalyticsComponent;
-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.AnalyticsDataFactory;
-import org.drools.analytics.report.components.PartialRedundancy;
-import org.drools.analytics.report.components.Redundancy;
-import org.drools.analytics.report.components.Subsumption;
-import org.drools.base.RuleNameMatchesAgendaFilter;
-
-/**
- *
- * @author Toni Rikkola
- *
- */
-public class RedundancyTest extends TestBase {
-
- public void testFake() {
- assertTrue(true);
- }
-
- public void fixmetestPartOfRulePossibilityRedundancy() throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("redundancy/Possibilities.drl"));
-
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Find part of redundant RulePossibility combination"));
-
- Collection<Object> data = new ArrayList<Object>();
-
- AnalyticsResult result = AnalyticsDataFactory
- .getAnalyticsResult();
- session.setGlobal("result", result);
-
- 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);
-
- 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);
-
- Redundancy redundancy1 = new Redundancy(pp1, pp2);
- Redundancy redundancy2 = new Redundancy(r1, r2);
-
- data.add(r1);
- data.add(r2);
- data.add(rp1);
- data.add(rp2);
- data.add(pp1);
- data.add(pp2);
- data.add(redundancy1);
- data.add(redundancy2);
-
- StatelessSessionResult sessionResult = session.executeWithResults(data);
-
- Map<String, Set<Redundancy>> map = new HashMap<String, Set<Redundancy>>();
-
- Iterator<Object> iter = sessionResult.iterateObjects();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof PartialRedundancy) {
- PartialRedundancy pr = (PartialRedundancy) o;
- AnalyticsComponent left = (AnalyticsComponent) pr.getLeft();
- AnalyticsComponent right = (AnalyticsComponent) pr.getRight();
-
- String key = left.getRuleName() + ":" + right.getRuleName();
- if (map.containsKey(key)) {
- Set<Redundancy> set = map.get(key);
- set.add(pr.getRedundancy());
- } else {
- Set<Redundancy> set = new HashSet<Redundancy>();
- set.add(pr.getRedundancy());
- map.put(key, set);
- }
- }
- }
-
- assertTrue(RedundancyTest.mapContains(map, ruleName1 + ":" + ruleName2,
- redundancy1));
-
- if (!map.isEmpty()) {
- fail("More redundancies than was expected.");
- }
- }
-
- public void fixmetestPossibilityRedundancy() throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("redundancy/Possibilities.drl"));
-
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Find redundant Possibilities"));
-
- Collection<Object> data = new ArrayList<Object>();
-
- AnalyticsResult result = AnalyticsDataFactory
- .getAnalyticsResult();
- session.setGlobal("result", result);
-
- String ruleName1 = "Rule 1";
- String ruleName2 = "Rule 2";
-
- PatternPossibility pp1 = new PatternPossibility();
- pp1.setRuleName(ruleName1);
-
- PatternPossibility pp2 = new PatternPossibility();
- pp2.setRuleName(ruleName2);
-
- Subsumption s1 = new Subsumption(pp1, pp2);
- Subsumption s2 = new Subsumption(pp2, pp1);
-
- data.add(pp1);
- data.add(pp2);
- data.add(s1);
- data.add(s2);
-
- StatelessSessionResult sessionResult = session.executeWithResults(data);
-
- Iterator<Object> iter = sessionResult.iterateObjects();
-
- Map<String, Set<String>> map = createRedundancyMap(iter);
-
- assertTrue(RedundancyTest.mapContains(map, ruleName2, ruleName1));
-
- if (!map.isEmpty()) {
- fail("More redundancies than was expected.");
- }
- }
-
- public void fixmetestPartOfPatternPossibilityRedundancy() throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("redundancy/Possibilities.drl"));
-
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Find part of redundant PatternPossibility combination"));
-
- Collection<Object> data = new ArrayList<Object>();
-
- AnalyticsResult result = AnalyticsDataFactory
- .getAnalyticsResult();
- 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);
-
- 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);
-
- 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(pp1);
- data.add(pp2);
- data.add(r1);
- data.add(r2);
-
- StatelessSessionResult sessionResult = session.executeWithResults(data);
-
- Map<String, Set<Redundancy>> map = new HashMap<String, Set<Redundancy>>();
-
- Iterator<Object> iter = sessionResult.iterateObjects();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof PartialRedundancy) {
- PartialRedundancy pr = (PartialRedundancy) o;
- AnalyticsComponent left = (AnalyticsComponent) pr.getLeft();
- AnalyticsComponent right = (AnalyticsComponent) pr.getRight();
-
- String key = left.getRuleName() + ":" + right.getRuleName();
- if (map.containsKey(key)) {
- Set<Redundancy> set = map.get(key);
- set.add(pr.getRedundancy());
- } else {
- Set<Redundancy> set = new HashSet<Redundancy>();
- set.add(pr.getRedundancy());
- map.put(key, set);
- }
- }
- }
-
- assertTrue(RedundancyTest.mapContains(map, ruleName1 + ":" + ruleName2,
- r1));
-
- if (!map.isEmpty()) {
- fail("More redundancies than was expected.");
- }
- }
-
- /*
- * Not enough data to test this right now.
- */
- /*
- * public void testRuleRedundancy() throws Exception { StatelessSession
- * session = getStatelessSession(this.getClass()
- * .getResourceAsStream("Redundancy.drl"));
- *
- * session.setAgendaFilter(new RuleNameMatchesAgendaFilter( "Find redundant
- * Rule shells"));
- *
- * Collection<Object> data = getTestData(this.getClass()
- * .getResourceAsStream("RuleRedundancyTest.drl"));
- *
- * AnalysisResultNormal analysisResult = new AnalysisResultNormal();
- * session.setGlobal("result", analysisResult);
- *
- * StatelessSessionResult sessionResult = session.executeWithResults(data);
- *
- * Map<String, Set<String>> map = createRedundancyMap(sessionResult
- * .iterateObjects());
- *
- * assertTrue(mapContains(map, "Rule redundancy 1a", "Rule redundancy 1b"));
- * assertTrue(mapContains(map, "Rule redundancy 1b", "Rule redundancy 1a"));
- * assertTrue(mapContains(map, "Rule redundancy 2a", "Rule redundancy 2b"));
- * assertTrue(mapContains(map, "Rule redundancy 2b", "Rule redundancy 2a"));
- * assertTrue(mapContains(map, "Rule redundancy 3a", "Rule redundancy 3b"));
- * assertTrue(mapContains(map, "Rule redundancy 3b", "Rule redundancy 3a"));
- * assertTrue(mapContains(map, "Rule redundancy 4a", "Rule redundancy 4b"));
- * assertTrue(mapContains(map, "Rule redundancy 4b", "Rule redundancy 4a"));
- *
- * if (!map.isEmpty()) { fail("More redundancies than was expected."); } }
- */
-
- public void fixmetestPatternRedundancy() throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("redundancy/Patterns.drl"));
-
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Find redundant Pattern shells"));
-
- Collection<? extends Object> data = getTestData(this.getClass()
- .getResourceAsStream("PatternRedundancyTest.drl"));
-
- AnalyticsResult result = AnalyticsDataFactory
- .getAnalyticsResult();
- session.setGlobal("result", result);
-
- StatelessSessionResult sessionResult = session.executeWithResults(data);
-
- Map<String, Set<String>> map = createRedundancyMap(sessionResult
- .iterateObjects());
-
- assertTrue(TestBase.mapContains(map, "Pattern redundancy 1a",
- "Pattern redundancy 1b"));
- assertTrue(TestBase.mapContains(map, "Pattern redundancy 1b",
- "Pattern redundancy 1a"));
- assertTrue(TestBase.mapContains(map, "Pattern redundancy 2a",
- "Pattern redundancy 2b"));
- assertTrue(TestBase.mapContains(map, "Pattern redundancy 2b",
- "Pattern redundancy 2a"));
- assertTrue(TestBase.mapContains(map, "Pattern redundancy 3a",
- "Pattern redundancy 3b"));
- assertTrue(TestBase.mapContains(map, "Pattern redundancy 3b",
- "Pattern redundancy 3a"));
- assertTrue(TestBase.mapContains(map, "Pattern redundancy 4a",
- "Pattern redundancy 4b"));
- assertTrue(TestBase.mapContains(map, "Pattern redundancy 4b",
- "Pattern redundancy 4a"));
-
- if (!map.isEmpty()) {
- fail("More redundancies than was expected.");
- }
- }
-
- public void fixmetestAnalyticsLiteralRestrictionRedundancy() throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("redundancy/Restrictions.drl"));
-
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Find redundant LiteralRestriction"));
-
- Collection<? extends Object> data = getTestData(this.getClass()
- .getResourceAsStream("RedundancyLiteralRestrictionTest.drl"));
-
- AnalyticsResult result = AnalyticsDataFactory
- .getAnalyticsResult();
- session.setGlobal("result", result);
-
- StatelessSessionResult sessionResult = session.executeWithResults(data);
-
- Map<String, Set<String>> map = createRedundancyMap(sessionResult
- .iterateObjects());
-
- assertTrue((TestBase.mapContains(map, "Redundant 1a", "Redundant 1b") ^ TestBase
- .mapContains(map, "Redundant 1b", "Redundant 1a")));
- assertTrue((TestBase.mapContains(map, "Redundant 2a", "Redundant 2b") ^ TestBase
- .mapContains(map, "Redundant 2b", "Redundant 2a")));
- assertTrue((TestBase.mapContains(map, "Redundant 3a", "Redundant 3b") ^ TestBase
- .mapContains(map, "Redundant 3b", "Redundant 3a")));
- assertTrue((TestBase.mapContains(map, "Redundant 4a", "Redundant 4b") ^ TestBase
- .mapContains(map, "Redundant 4b", "Redundant 4a")));
- assertTrue((TestBase.mapContains(map, "Redundant 5a", "Redundant 5b") ^ TestBase
- .mapContains(map, "Redundant 5b", "Redundant 5a")));
- assertTrue((TestBase.mapContains(map, "Redundant 6a", "Redundant 6b") ^ TestBase
- .mapContains(map, "Redundant 6b", "Redundant 6a")));
-
- if (!map.isEmpty()) {
- fail("More redundancies than was expected.");
- }
- }
-
- public void fixmetestAnalyticsVariableRestrictionRedundancy()
- throws Exception {
- StatelessSession session = getStatelessSession(this.getClass()
- .getResourceAsStream("redundancy/Restrictions.drl"));
-
- session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
- "Find redundant VariableRestriction"));
-
- Collection<? extends Object> data = getTestData(this.getClass()
- .getResourceAsStream("SubsumptionVariableRestrictionTest.drl"));
-
- AnalyticsResult result = AnalyticsDataFactory
- .getAnalyticsResult();
- session.setGlobal("result", result);
-
- StatelessSessionResult sessionResult = session.executeWithResults(data);
-
- Map<String, Set<String>> map = createRedundancyMap(sessionResult
- .iterateObjects());
-
- assertTrue(TestBase.mapContains(map, "Redundant 1a", "Redundant 1b"));
- assertTrue(TestBase.mapContains(map, "Redundant 1b", "Redundant 1a"));
- assertTrue(TestBase.mapContains(map, "Redundant 2a", "Redundant 2a"));
-
- if (!map.isEmpty()) {
- fail("More redundancies than was expected.");
- }
- }
-
- /**
- * Creates redundancy map from Redundancy objects, one rule may have several
- * redundancy dependencies.
- *
- * @param iter
- * @return
- */
- private Map<String, Set<String>> createRedundancyMap(Iterator<Object> iter) {
-
- Map<String, Set<String>> map = new HashMap<String, Set<String>>();
- while (iter.hasNext()) {
- Object o = (Object) iter.next();
- if (o instanceof Redundancy) {
- Redundancy r = (Redundancy) o;
- AnalyticsComponent left = (AnalyticsComponent) r.getLeft();
- AnalyticsComponent right = (AnalyticsComponent) r.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;
- }
-
- /**
- * Returns true if map contains redundancy where key is redundant to value.
- *
- * @param map
- * @param key
- * @param value
- * @return True if redundancy exists.
- */
- private static boolean mapContains(Map<String, Set<Redundancy>> map,
- String key, Object value) {
- if (map.containsKey(key)) {
- Set<Redundancy> set = map.get(key);
- boolean exists = set.remove(value);
-
- // If set is empty remove key from map.
- if (set.isEmpty()) {
- map.remove(key);
- }
- return exists;
- }
- return false;
- }
-}
Copied: labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/redundancy/RedundancyTest.java (from rev 16749, labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/RedundancyTest.java)
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/redundancy/RedundancyTest.java (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/redundancy/RedundancyTest.java 2007-11-22 14:14:32 UTC (rev 16750)
@@ -0,0 +1,430 @@
+package org.drools.analytics.redundancy;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+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.AnalyticsComponent;
+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.AnalyticsDataFactory;
+import org.drools.analytics.report.components.PartialRedundancy;
+import org.drools.analytics.report.components.Redundancy;
+import org.drools.analytics.report.components.Subsumption;
+import org.drools.base.RuleNameMatchesAgendaFilter;
+
+/**
+ *
+ * @author Toni Rikkola
+ *
+ */
+public class RedundancyTest extends TestBase {
+
+ public void testFake() {
+ assertTrue(true);
+ }
+
+ public void fixmetestPartOfRulePossibilityRedundancy() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Possibilities.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Find part of redundant RulePossibility combination"));
+
+ Collection<Object> data = new ArrayList<Object>();
+
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ 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);
+
+ 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);
+
+ Redundancy redundancy1 = new Redundancy(pp1, pp2);
+ Redundancy redundancy2 = new Redundancy(r1, r2);
+
+ data.add(r1);
+ data.add(r2);
+ data.add(rp1);
+ data.add(rp2);
+ data.add(pp1);
+ data.add(pp2);
+ data.add(redundancy1);
+ data.add(redundancy2);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<String, Set<Redundancy>> map = new HashMap<String, Set<Redundancy>>();
+
+ Iterator<Object> iter = sessionResult.iterateObjects();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof PartialRedundancy) {
+ PartialRedundancy pr = (PartialRedundancy) o;
+ AnalyticsComponent left = (AnalyticsComponent) pr.getLeft();
+ AnalyticsComponent right = (AnalyticsComponent) pr.getRight();
+
+ String key = left.getRuleName() + ":" + right.getRuleName();
+ if (map.containsKey(key)) {
+ Set<Redundancy> set = map.get(key);
+ set.add(pr.getRedundancy());
+ } else {
+ Set<Redundancy> set = new HashSet<Redundancy>();
+ set.add(pr.getRedundancy());
+ map.put(key, set);
+ }
+ }
+ }
+
+ assertTrue(RedundancyTest.mapContains(map, ruleName1 + ":" + ruleName2,
+ redundancy1));
+
+ if (!map.isEmpty()) {
+ fail("More redundancies than was expected.");
+ }
+ }
+
+ public void fixmetestPossibilityRedundancy() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Possibilities.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Find redundant Possibilities"));
+
+ Collection<Object> data = new ArrayList<Object>();
+
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ String ruleName1 = "Rule 1";
+ String ruleName2 = "Rule 2";
+
+ PatternPossibility pp1 = new PatternPossibility();
+ pp1.setRuleName(ruleName1);
+
+ PatternPossibility pp2 = new PatternPossibility();
+ pp2.setRuleName(ruleName2);
+
+ Subsumption s1 = new Subsumption(pp1, pp2);
+ Subsumption s2 = new Subsumption(pp2, pp1);
+
+ data.add(pp1);
+ data.add(pp2);
+ data.add(s1);
+ data.add(s2);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Iterator<Object> iter = sessionResult.iterateObjects();
+
+ Map<String, Set<String>> map = createRedundancyMap(iter);
+
+ assertTrue(RedundancyTest.mapContains(map, ruleName2, ruleName1));
+
+ if (!map.isEmpty()) {
+ fail("More redundancies than was expected.");
+ }
+ }
+
+ public void fixmetestPartOfPatternPossibilityRedundancy() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Possibilities.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Find part of redundant PatternPossibility combination"));
+
+ Collection<Object> data = new ArrayList<Object>();
+
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ 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);
+
+ 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);
+
+ 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(pp1);
+ data.add(pp2);
+ data.add(r1);
+ data.add(r2);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<String, Set<Redundancy>> map = new HashMap<String, Set<Redundancy>>();
+
+ Iterator<Object> iter = sessionResult.iterateObjects();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof PartialRedundancy) {
+ PartialRedundancy pr = (PartialRedundancy) o;
+ AnalyticsComponent left = (AnalyticsComponent) pr.getLeft();
+ AnalyticsComponent right = (AnalyticsComponent) pr.getRight();
+
+ String key = left.getRuleName() + ":" + right.getRuleName();
+ if (map.containsKey(key)) {
+ Set<Redundancy> set = map.get(key);
+ set.add(pr.getRedundancy());
+ } else {
+ Set<Redundancy> set = new HashSet<Redundancy>();
+ set.add(pr.getRedundancy());
+ map.put(key, set);
+ }
+ }
+ }
+
+ assertTrue(RedundancyTest.mapContains(map, ruleName1 + ":" + ruleName2,
+ r1));
+
+ if (!map.isEmpty()) {
+ fail("More redundancies than was expected.");
+ }
+ }
+
+ /*
+ * Not enough data to test this right now.
+ */
+ /*
+ * public void testRuleRedundancy() throws Exception { StatelessSession
+ * session = getStatelessSession(this.getClass()
+ * .getResourceAsStream("Redundancy.drl"));
+ *
+ * session.setAgendaFilter(new RuleNameMatchesAgendaFilter( "Find redundant
+ * Rule shells"));
+ *
+ * Collection<Object> data = getTestData(this.getClass()
+ * .getResourceAsStream("RuleRedundancyTest.drl"));
+ *
+ * AnalysisResultNormal analysisResult = new AnalysisResultNormal();
+ * session.setGlobal("result", analysisResult);
+ *
+ * StatelessSessionResult sessionResult = session.executeWithResults(data);
+ *
+ * Map<String, Set<String>> map = createRedundancyMap(sessionResult
+ * .iterateObjects());
+ *
+ * assertTrue(mapContains(map, "Rule redundancy 1a", "Rule redundancy 1b"));
+ * assertTrue(mapContains(map, "Rule redundancy 1b", "Rule redundancy 1a"));
+ * assertTrue(mapContains(map, "Rule redundancy 2a", "Rule redundancy 2b"));
+ * assertTrue(mapContains(map, "Rule redundancy 2b", "Rule redundancy 2a"));
+ * assertTrue(mapContains(map, "Rule redundancy 3a", "Rule redundancy 3b"));
+ * assertTrue(mapContains(map, "Rule redundancy 3b", "Rule redundancy 3a"));
+ * assertTrue(mapContains(map, "Rule redundancy 4a", "Rule redundancy 4b"));
+ * assertTrue(mapContains(map, "Rule redundancy 4b", "Rule redundancy 4a"));
+ *
+ * if (!map.isEmpty()) { fail("More redundancies than was expected."); } }
+ */
+
+ public void fixmetestPatternRedundancy() throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Patterns.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Find redundant Pattern shells"));
+
+ Collection<? extends Object> data = getTestData(this.getClass()
+ .getResourceAsStream("PatternRedundancyTest.drl"));
+
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<String, Set<String>> map = createRedundancyMap(sessionResult
+ .iterateObjects());
+
+ assertTrue(TestBase.mapContains(map, "Pattern redundancy 1a",
+ "Pattern redundancy 1b"));
+ assertTrue(TestBase.mapContains(map, "Pattern redundancy 1b",
+ "Pattern redundancy 1a"));
+ assertTrue(TestBase.mapContains(map, "Pattern redundancy 2a",
+ "Pattern redundancy 2b"));
+ assertTrue(TestBase.mapContains(map, "Pattern redundancy 2b",
+ "Pattern redundancy 2a"));
+ assertTrue(TestBase.mapContains(map, "Pattern redundancy 3a",
+ "Pattern redundancy 3b"));
+ assertTrue(TestBase.mapContains(map, "Pattern redundancy 3b",
+ "Pattern redundancy 3a"));
+ assertTrue(TestBase.mapContains(map, "Pattern redundancy 4a",
+ "Pattern redundancy 4b"));
+ assertTrue(TestBase.mapContains(map, "Pattern redundancy 4b",
+ "Pattern redundancy 4a"));
+
+ if (!map.isEmpty()) {
+ fail("More redundancies than was expected.");
+ }
+ }
+
+ public void fixmetestAnalyticsLiteralRestrictionRedundancy()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Find redundant LiteralRestriction"));
+
+ Collection<? extends Object> data = getTestData(this.getClass()
+ .getResourceAsStream("RedundancyLiteralRestrictionTest.drl"));
+
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<String, Set<String>> map = createRedundancyMap(sessionResult
+ .iterateObjects());
+
+ assertTrue((TestBase.mapContains(map, "Redundant 1a", "Redundant 1b") ^ TestBase
+ .mapContains(map, "Redundant 1b", "Redundant 1a")));
+ assertTrue((TestBase.mapContains(map, "Redundant 2a", "Redundant 2b") ^ TestBase
+ .mapContains(map, "Redundant 2b", "Redundant 2a")));
+ assertTrue((TestBase.mapContains(map, "Redundant 3a", "Redundant 3b") ^ TestBase
+ .mapContains(map, "Redundant 3b", "Redundant 3a")));
+ assertTrue((TestBase.mapContains(map, "Redundant 4a", "Redundant 4b") ^ TestBase
+ .mapContains(map, "Redundant 4b", "Redundant 4a")));
+ assertTrue((TestBase.mapContains(map, "Redundant 5a", "Redundant 5b") ^ TestBase
+ .mapContains(map, "Redundant 5b", "Redundant 5a")));
+ assertTrue((TestBase.mapContains(map, "Redundant 6a", "Redundant 6b") ^ TestBase
+ .mapContains(map, "Redundant 6b", "Redundant 6a")));
+
+ if (!map.isEmpty()) {
+ fail("More redundancies than was expected.");
+ }
+ }
+
+ public void fixmetestAnalyticsVariableRestrictionRedundancy()
+ throws Exception {
+ StatelessSession session = getStatelessSession(this.getClass()
+ .getResourceAsStream("Restrictions.drl"));
+
+ session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+ "Find redundant VariableRestriction"));
+
+ Collection<? extends Object> data = getTestData(this.getClass()
+ .getResourceAsStream("SubsumptionVariableRestrictionTest.drl"));
+
+ AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
+ session.setGlobal("result", result);
+
+ StatelessSessionResult sessionResult = session.executeWithResults(data);
+
+ Map<String, Set<String>> map = createRedundancyMap(sessionResult
+ .iterateObjects());
+
+ assertTrue(TestBase.mapContains(map, "Redundant 1a", "Redundant 1b"));
+ assertTrue(TestBase.mapContains(map, "Redundant 1b", "Redundant 1a"));
+ assertTrue(TestBase.mapContains(map, "Redundant 2a", "Redundant 2a"));
+
+ if (!map.isEmpty()) {
+ fail("More redundancies than was expected.");
+ }
+ }
+
+ /**
+ * Creates redundancy map from Redundancy objects, one rule may have several
+ * redundancy dependencies.
+ *
+ * @param iter
+ * @return
+ */
+ private Map<String, Set<String>> createRedundancyMap(Iterator<Object> iter) {
+
+ Map<String, Set<String>> map = new HashMap<String, Set<String>>();
+ while (iter.hasNext()) {
+ Object o = (Object) iter.next();
+ if (o instanceof Redundancy) {
+ Redundancy r = (Redundancy) o;
+ AnalyticsComponent left = (AnalyticsComponent) r.getLeft();
+ AnalyticsComponent right = (AnalyticsComponent) r.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;
+ }
+
+ /**
+ * Returns true if map contains redundancy where key is redundant to value.
+ *
+ * @param map
+ * @param key
+ * @param value
+ * @return True if redundancy exists.
+ */
+ private static boolean mapContains(Map<String, Set<Redundancy>> map,
+ String key, Object value) {
+ if (map.containsKey(key)) {
+ Set<Redundancy> set = map.get(key);
+ boolean exists = set.remove(value);
+
+ // If set is empty remove key from map.
+ if (set.isEmpty()) {
+ map.remove(key);
+ }
+ return exists;
+ }
+ return false;
+ }
+}
Deleted: labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/PatternRedundancyTest.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/PatternRedundancyTest.drl 2007-11-22 13:16:13 UTC (rev 16749)
+++ labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/PatternRedundancyTest.drl 2007-11-22 14:14:32 UTC (rev 16750)
@@ -1,59 +0,0 @@
-package com.sample
-
-import com.sample.DroolsTest.Message;
-
-rule "Pattern redundancy 1a"
- when
- Foo1()
- then
- System.out.println( "Test" );
-end
-
-rule "Pattern redundancy 1b"
- when
- Foo1()
- then
- System.out.println( "Test" );
-end
-
-rule "Pattern redundancy 2a"
- when
- not Foo2()
- then
- System.out.println( "Test" );
-end
-
-rule "Pattern redundancy 2b"
- when
- not Foo2()
- then
- System.out.println( "Test" );
-end
-
-rule "Pattern redundancy 3a"
- when
- exists Foo3()
- then
- System.out.println( "Test" );
-end
-
-rule "Pattern redundancy 3b"
- when
- exists Foo3()
- then
- System.out.println( "Test" );
-end
-
-rule "Pattern redundancy 4a"
- when
- forall( Foo4() )
- then
- System.out.println( "Test" );
-end
-
-rule "Pattern redundancy 4b"
- when
- forall( Foo4() )
- then
- System.out.println( "Test" );
-end
Copied: labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/redundancy/PatternRedundancyTest.drl (from rev 16749, labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/PatternRedundancyTest.drl)
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/redundancy/PatternRedundancyTest.drl (rev 0)
+++ labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/redundancy/PatternRedundancyTest.drl 2007-11-22 14:14:32 UTC (rev 16750)
@@ -0,0 +1,59 @@
+package com.sample
+
+import com.sample.DroolsTest.Message;
+
+rule "Pattern redundancy 1a"
+ when
+ Foo1()
+ then
+ System.out.println( "Test" );
+end
+
+rule "Pattern redundancy 1b"
+ when
+ Foo1()
+ then
+ System.out.println( "Test" );
+end
+
+rule "Pattern redundancy 2a"
+ when
+ not Foo2()
+ then
+ System.out.println( "Test" );
+end
+
+rule "Pattern redundancy 2b"
+ when
+ not Foo2()
+ then
+ System.out.println( "Test" );
+end
+
+rule "Pattern redundancy 3a"
+ when
+ exists Foo3()
+ then
+ System.out.println( "Test" );
+end
+
+rule "Pattern redundancy 3b"
+ when
+ exists Foo3()
+ then
+ System.out.println( "Test" );
+end
+
+rule "Pattern redundancy 4a"
+ when
+ forall( Foo4() )
+ then
+ System.out.println( "Test" );
+end
+
+rule "Pattern redundancy 4b"
+ when
+ forall( Foo4() )
+ then
+ System.out.println( "Test" );
+end
More information about the jboss-svn-commits
mailing list