[jboss-svn-commits] JBL Code SVN: r16795 - in labs/jbossrules/trunk/drools-analytics/src: test/java/org/drools/analytics/redundancy and 1 other directories.

[jboss-svn-commits at lists.jboss.org]

Author: Rikkola
Date: 2007-11-25 07:36:53 -0500 (Sun, 25 Nov 2007)
New Revision: 16795

Modified:
   labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/redundancy/Patterns.drl
   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/PatternRedundancyTest.drl
Log:
Fixed some old redundancy unit tests that had bugs.

Modified: labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/redundancy/Patterns.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/redundancy/Patterns.drl	2007-11-25 12:28:20 UTC (rev 16794)
+++ labs/jbossrules/trunk/drools-analytics/src/main/resources/org/drools/analytics/redundancy/Patterns.drl	2007-11-25 12:36:53 UTC (rev 16795)
@@ -8,7 +8,7 @@
 # Only checks for redundant pattern specifications, 
 # does not include actual restriction checks.
 #
-rule "Find redundant Pattern shells"
+rule "Find redundant Patterns with restrictions"
 	when
 		# Check that Patterns $left and $right have redundant fields.
 		$left :Pattern()
@@ -25,6 +25,7 @@
 		
 		# Has possibilities, if the there is no possibilities, 
 		# then the Redundancy type is STRONG.
+		# Because these patterns have no restrictions.
 		exists PatternPossibility( patternId == $left.id )
 		exists PatternPossibility( patternId == $right.id )
 		

Modified: labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/redundancy/RedundancyTest.java
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/redundancy/RedundancyTest.java	2007-11-25 12:28:20 UTC (rev 16794)
+++ labs/jbossrules/trunk/drools-analytics/src/test/java/org/drools/analytics/redundancy/RedundancyTest.java	2007-11-25 12:36:53 UTC (rev 16795)
@@ -252,16 +252,18 @@
 	 * if (!map.isEmpty()) { fail("More redundancies than was expected."); } }
 	 */
 
-	public void fixmetestPatternRedundancy() throws Exception {
+	public void testPatternRedundancyWithRestrictions() throws Exception {
 		StatelessSession session = getStatelessSession(this.getClass()
 				.getResourceAsStream("Patterns.drl"));
 
 		session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
-				"Find redundant Pattern shells"));
+				"Find redundant Patterns with restrictions"));
 
+		AnalyticsDataFactory.clearAnalyticsData();
 		Collection<? extends Object> data = getTestData(this.getClass()
 				.getResourceAsStream("PatternRedundancyTest.drl"));
 
+		AnalyticsDataFactory.clearAnalyticsResult();
 		AnalyticsResult result = AnalyticsDataFactory.getAnalyticsResult();
 		session.setGlobal("result", result);
 
@@ -270,28 +272,86 @@
 		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"));
+		assertTrue(TestBase.mapContains(map,
+				"Pattern redundancy with restrictions 1a",
+				"Pattern redundancy with restrictions 1b")
+				^ TestBase.mapContains(map,
+						"Pattern redundancy with restrictions 1b",
+						"Pattern redundancy with restrictions 1a"));
+		assertTrue(TestBase.mapContains(map,
+				"Pattern redundancy with restrictions 2a",
+				"Pattern redundancy with restrictions 2b")
+				^ TestBase.mapContains(map,
+						"Pattern redundancy with restrictions 2b",
+						"Pattern redundancy with restrictions 2a"));
+		assertTrue(TestBase.mapContains(map,
+				"Pattern redundancy with restrictions 3a",
+				"Pattern redundancy with restrictions 3b")
+				^ TestBase.mapContains(map,
+						"Pattern redundancy with restrictions 3b",
+						"Pattern redundancy with restrictions 3a"));
+		assertTrue(TestBase.mapContains(map,
+				"Pattern redundancy with restrictions 4a",
+				"Pattern redundancy with restrictions 4b")
+				^ TestBase.mapContains(map,
+						"Pattern redundancy with restrictions 4b",
+						"Pattern redundancy with restrictions 4a"));
 
 		if (!map.isEmpty()) {
 			fail("More redundancies than was expected.");
 		}
 	}
 
+	public void testPatternRedundancyWithoutRestrictions() throws Exception {
+		StatelessSession session = getStatelessSession(this.getClass()
+				.getResourceAsStream("Patterns.drl"));
+
+		session.setAgendaFilter(new RuleNameMatchesAgendaFilter(
+				"Find redundant Patterns without restrictions"));
+
+		AnalyticsDataFactory.clearAnalyticsData();
+		Collection<? extends Object> data = getTestData(this.getClass()
+				.getResourceAsStream("PatternRedundancyTest.drl"));
+
+		AnalyticsDataFactory.clearAnalyticsResult();
+		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 without restrictions 1a",
+				"Pattern redundancy without restrictions 1b")
+				^ TestBase.mapContains(map,
+						"Pattern redundancy without restrictions 1b",
+						"Pattern redundancy without restrictions 1a"));
+		assertTrue(TestBase.mapContains(map,
+				"Pattern redundancy without restrictions 2a",
+				"Pattern redundancy without restrictions 2b")
+				^ TestBase.mapContains(map,
+						"Pattern redundancy without restrictions 2b",
+						"Pattern redundancy without restrictions 2a"));
+		assertTrue(TestBase.mapContains(map,
+				"Pattern redundancy without restrictions 3a",
+				"Pattern redundancy without restrictions 3b")
+				^ TestBase.mapContains(map,
+						"Pattern redundancy without restrictions 3b",
+						"Pattern redundancy without restrictions 3a"));
+		assertTrue(TestBase.mapContains(map,
+				"Pattern redundancy without restrictions 4a",
+				"Pattern redundancy without restrictions 4b")
+				^ TestBase.mapContains(map,
+						"Pattern redundancy without restrictions 4b",
+						"Pattern redundancy without restrictions 4a"));
+
+		if (!map.isEmpty()) {
+			fail("More redundancies than was expected.");
+		}
+	}
+
 	public void testAnalyticsLiteralRestrictionRedundancy() throws Exception {
 		StatelessSession session = getStatelessSession(this.getClass()
 				.getResourceAsStream("Restrictions.drl"));

Modified: labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/redundancy/PatternRedundancyTest.drl
===================================================================
--- labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/redundancy/PatternRedundancyTest.drl	2007-11-25 12:28:20 UTC (rev 16794)
+++ labs/jbossrules/trunk/drools-analytics/src/test/resources/org/drools/analytics/redundancy/PatternRedundancyTest.drl	2007-11-25 12:36:53 UTC (rev 16795)
@@ -2,58 +2,118 @@
 
 import com.sample.DroolsTest.Message;
 
-rule "Pattern redundancy 1a"
+rule "Pattern redundancy without restrictions 1a"
 	when
 		    Foo1()
 	then
 		System.out.println( "Test" );
 end
 
-rule "Pattern redundancy 1b"
+rule "Pattern redundancy without restrictions 1b"
 	when
 		    Foo1()
 	then
 		System.out.println( "Test" );
 end
 
-rule "Pattern redundancy 2a"
+rule "Pattern redundancy without restrictions 2a"
 	when
 		    not Foo2()
 	then
 		System.out.println( "Test" );
 end
 
-rule "Pattern redundancy 2b"
+rule "Pattern redundancy without restrictions 2b"
 	when
 		    not Foo2()
 	then
 		System.out.println( "Test" );
 end
 
-rule "Pattern redundancy 3a"
+rule "Pattern redundancy without restrictions 3a"
 	when
 		    exists Foo3()
 	then
 		System.out.println( "Test" );
 end
 
-rule "Pattern redundancy 3b"
+rule "Pattern redundancy without restrictions 3b"
 	when
 		    exists Foo3()
 	then
 		System.out.println( "Test" );
 end
 
-rule "Pattern redundancy 4a"
+rule "Pattern redundancy without restrictions 4a"
 	when
 		    forall( Foo4() )
 	then
 		System.out.println( "Test" );
 end
 
-rule "Pattern redundancy 4b"
+rule "Pattern redundancy without restrictions 4b"
 	when
 		    forall( Foo4() )
 	then
 		System.out.println( "Test" );
 end
+
+#
+# With restrictions.
+#
+
+rule "Pattern redundancy with restrictions 1a"
+	when
+		    Foo1( a == "b" )
+	then
+		System.out.println( "Test" );
+end
+
+rule "Pattern redundancy with restrictions 1b"
+	when
+		    Foo1( a == "b" )
+	then
+		System.out.println( "Test" );
+end
+
+rule "Pattern redundancy with restrictions 2a"
+	when
+		    not Foo2( a == "b" )
+	then
+		System.out.println( "Test" );
+end
+
+rule "Pattern redundancy with restrictions 2b"
+	when
+		    not Foo2( a == "b" )
+	then
+		System.out.println( "Test" );
+end
+
+rule "Pattern redundancy with restrictions 3a"
+	when
+		    exists Foo3( a == "b" )
+	then
+		System.out.println( "Test" );
+end
+
+rule "Pattern redundancy with restrictions 3b"
+	when
+		    exists Foo3( a == "b" )
+	then
+		System.out.println( "Test" );
+end
+
+rule "Pattern redundancy with restrictions 4a"
+	when
+		    forall( Foo4( a == "b" ) )
+	then
+		System.out.println( "Test" );
+end
+
+rule "Pattern redundancy with restrictions 4b"
+	when
+		    forall( Foo4( a == "b" ) )
+	then
+		System.out.println( "Test" );
+end