001: package org.drools.integrationtests;
002:
003: import java.io.IOException;
004: import java.io.InputStreamReader;
005: import java.io.Reader;
006: import java.util.ArrayList;
007: import java.util.Collection;
008: import java.util.List;
009:
010: import junit.framework.Assert;
011: import junit.framework.TestCase;
012:
013: import org.drools.Cheese;
014: import org.drools.Cheesery;
015: import org.drools.FactHandle;
016: import org.drools.Person;
017: import org.drools.PersonInterface;
018: import org.drools.RuleBase;
019: import org.drools.RuleBaseConfiguration;
020: import org.drools.RuleBaseFactory;
021: import org.drools.SpecialString;
022: import org.drools.State;
023: import org.drools.StatefulSession;
024: import org.drools.WorkingMemory;
025: import org.drools.compiler.DrlParser;
026: import org.drools.compiler.DroolsParserException;
027: import org.drools.compiler.PackageBuilder;
028: import org.drools.lang.descr.PackageDescr;
029: import org.drools.rule.Package;
030: import org.drools.rule.Rule;
031:
032: public class FirstOrderLogicTest extends TestCase {
033: protected RuleBase getRuleBase() throws Exception {
034:
035: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, null);
036: }
037:
038: protected RuleBase getRuleBase(final RuleBaseConfiguration config)
039: throws Exception {
040:
041: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, config);
042: }
043:
044: public void testCollect() throws Exception {
045:
046: // read in the source
047: final Reader reader = new InputStreamReader(getClass()
048: .getResourceAsStream("test_Collect.drl"));
049: final RuleBase ruleBase = loadRuleBase(reader);
050:
051: final WorkingMemory wm = ruleBase.newStatefulSession();
052: final List results = new ArrayList();
053:
054: wm.setGlobal("results", results);
055:
056: wm.insert(new Cheese("stilton", 10));
057: wm.insert(new Cheese("stilton", 7));
058: wm.insert(new Cheese("stilton", 8));
059: wm.insert(new Cheese("brie", 5));
060: wm.insert(new Cheese("provolone", 150));
061: wm.insert(new Cheese("provolone", 20));
062: wm.insert(new Person("Bob", "stilton"));
063: wm.insert(new Person("Mark", "provolone"));
064:
065: wm.fireAllRules();
066:
067: Assert.assertEquals(1, results.size());
068: Assert.assertEquals(3, ((Collection) results.get(0)).size());
069: Assert.assertEquals(ArrayList.class.getName(), results.get(0)
070: .getClass().getName());
071: }
072:
073: public void testCollectModify() throws Exception {
074: // read in the source
075: final Reader reader = new InputStreamReader(getClass()
076: .getResourceAsStream("test_Collect.drl"));
077: final RuleBase ruleBase = loadRuleBase(reader);
078:
079: final WorkingMemory wm = ruleBase.newStatefulSession();
080: final List results = new ArrayList();
081:
082: wm.setGlobal("results", results);
083:
084: final Cheese[] cheese = new Cheese[] {
085: new Cheese("stilton", 10), new Cheese("stilton", 2),
086: new Cheese("stilton", 5), new Cheese("brie", 15),
087: new Cheese("brie", 16), new Cheese("provolone", 8) };
088: final Person bob = new Person("Bob", "stilton");
089:
090: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
091: for (int i = 0; i < cheese.length; i++) {
092: cheeseHandles[i] = wm.insert(cheese[i]);
093: }
094: final FactHandle bobHandle = wm.insert(bob);
095:
096: // ---------------- 1st scenario
097: int fireCount = 0;
098: wm.fireAllRules();
099: Assert.assertEquals(++fireCount, results.size());
100: Assert.assertEquals(3,
101: ((Collection) results.get(fireCount - 1)).size());
102: Assert.assertEquals(ArrayList.class.getName(), results.get(
103: fireCount - 1).getClass().getName());
104:
105: // ---------------- 2nd scenario
106: final int index = 1;
107: cheese[index].setPrice(9);
108: wm.update(cheeseHandles[index], cheese[index]);
109: wm.fireAllRules();
110:
111: Assert.assertEquals(++fireCount, results.size());
112: Assert.assertEquals(3,
113: ((Collection) results.get(fireCount - 1)).size());
114: Assert.assertEquals(ArrayList.class.getName(), results.get(
115: fireCount - 1).getClass().getName());
116:
117: // ---------------- 3rd scenario
118: bob.setLikes("brie");
119: wm.update(bobHandle, bob);
120: wm.fireAllRules();
121:
122: Assert.assertEquals(fireCount, results.size());
123:
124: // ---------------- 4th scenario
125: wm.retract(cheeseHandles[3]);
126: wm.fireAllRules();
127:
128: // should not have fired as per constraint
129: Assert.assertEquals(fireCount, results.size());
130: }
131:
132: public void testExistsWithBinding() throws Exception {
133: final PackageBuilder builder = new PackageBuilder();
134: builder.addPackageFromDrl(new InputStreamReader(getClass()
135: .getResourceAsStream("test_ExistsWithBindings.drl")));
136: final Package pkg = builder.getPackage();
137:
138: final RuleBase ruleBase = getRuleBase();
139: ruleBase.addPackage(pkg);
140: final WorkingMemory workingMemory = ruleBase
141: .newStatefulSession();
142:
143: final List list = new ArrayList();
144: workingMemory.setGlobal("results", list);
145:
146: final Cheese c = new Cheese("stilton", 10);
147: final Person p = new Person("Mark", "stilton");
148: workingMemory.insert(c);
149: workingMemory.insert(p);
150: workingMemory.fireAllRules();
151:
152: assertTrue(list.contains(c.getType()));
153: assertEquals(1, list.size());
154: }
155:
156: public void testNot() throws Exception {
157: final PackageBuilder builder = new PackageBuilder();
158: builder.addPackageFromDrl(new InputStreamReader(getClass()
159: .getResourceAsStream("not_rule_test.drl")));
160: final Package pkg = builder.getPackage();
161:
162: final RuleBase ruleBase = getRuleBase();
163: ruleBase.addPackage(pkg);
164: final WorkingMemory workingMemory = ruleBase
165: .newStatefulSession();
166:
167: final List list = new ArrayList();
168: workingMemory.setGlobal("list", list);
169:
170: final Cheese stilton = new Cheese("stilton", 5);
171: final FactHandle stiltonHandle = workingMemory.insert(stilton);
172: final Cheese cheddar = new Cheese("cheddar", 7);
173: final FactHandle cheddarHandle = workingMemory.insert(cheddar);
174: workingMemory.fireAllRules();
175:
176: assertEquals(0, list.size());
177:
178: workingMemory.retract(stiltonHandle);
179:
180: workingMemory.fireAllRules();
181:
182: assertEquals(4, list.size());
183: Assert.assertTrue(list.contains(new Integer(5)));
184: Assert.assertTrue(list.contains(new Integer(6)));
185: Assert.assertTrue(list.contains(new Integer(7)));
186: Assert.assertTrue(list.contains(new Integer(8)));
187: }
188:
189: public void testNotWithBindings() throws Exception {
190: final PackageBuilder builder = new PackageBuilder();
191: builder
192: .addPackageFromDrl(new InputStreamReader(getClass()
193: .getResourceAsStream(
194: "not_with_bindings_rule_test.drl")));
195: final Package pkg = builder.getPackage();
196:
197: final Rule rule = pkg.getRules()[0];
198: assertTrue(rule.isValid());
199: assertEquals(0, builder.getErrors().getErrors().length);
200: final RuleBase ruleBase = getRuleBase();
201: ruleBase.addPackage(pkg);
202: final WorkingMemory workingMemory = ruleBase
203: .newStatefulSession();
204:
205: final List list = new ArrayList();
206: workingMemory.setGlobal("list", list);
207:
208: final Cheese stilton = new Cheese("stilton", 5);
209: final FactHandle stiltonHandle = workingMemory.insert(stilton);
210: final Cheese cheddar = new Cheese("cheddar", 7);
211: final FactHandle cheddarHandle = workingMemory.insert(cheddar);
212:
213: final PersonInterface paul = new Person("paul", "stilton", 12);
214: workingMemory.insert(paul);
215: workingMemory.fireAllRules();
216:
217: assertEquals(0, list.size());
218:
219: workingMemory.retract(stiltonHandle);
220:
221: workingMemory.fireAllRules();
222:
223: assertEquals(1, list.size());
224: }
225:
226: public void testExists() throws Exception {
227: final PackageBuilder builder = new PackageBuilder();
228: builder.addPackageFromDrl(new InputStreamReader(getClass()
229: .getResourceAsStream("exists_rule_test.drl")));
230: final Package pkg = builder.getPackage();
231:
232: final RuleBase ruleBase = getRuleBase();
233: ruleBase.addPackage(pkg);
234: final WorkingMemory workingMemory = ruleBase
235: .newStatefulSession();
236:
237: final List list = new ArrayList();
238: workingMemory.setGlobal("list", list);
239:
240: final Cheese cheddar = new Cheese("cheddar", 7);
241: final FactHandle cheddarHandle = workingMemory.insert(cheddar);
242: workingMemory.fireAllRules();
243:
244: assertEquals(0, list.size());
245:
246: final Cheese stilton = new Cheese("stilton", 5);
247: final FactHandle stiltonHandle = workingMemory.insert(stilton);
248: workingMemory.fireAllRules();
249:
250: assertEquals(1, list.size());
251:
252: final Cheese brie = new Cheese("brie", 5);
253: final FactHandle brieHandle = workingMemory.insert(brie);
254: workingMemory.fireAllRules();
255:
256: assertEquals(1, list.size());
257: }
258:
259: public void testExists2() throws Exception {
260: final PackageBuilder builder = new PackageBuilder();
261: builder.addPackageFromDrl(new InputStreamReader(getClass()
262: .getResourceAsStream("test_exists.drl")));
263: final Package pkg = builder.getPackage();
264:
265: final RuleBase ruleBase = getRuleBase();
266: ruleBase.addPackage(pkg);
267: final WorkingMemory workingMemory = ruleBase
268: .newStatefulSession();
269:
270: final List list = new ArrayList();
271: workingMemory.setGlobal("list", list);
272:
273: final Cheese cheddar = new Cheese("cheddar", 7);
274: final Cheese provolone = new Cheese("provolone", 5);
275: final Person edson = new Person("Edson", "cheddar");
276: final Person bob = new Person("Bob", "muzzarela");
277:
278: workingMemory.insert(cheddar);
279: workingMemory.fireAllRules();
280: assertEquals(0, list.size());
281:
282: workingMemory.insert(provolone);
283: workingMemory.fireAllRules();
284: assertEquals(0, list.size());
285:
286: workingMemory.insert(edson);
287: workingMemory.fireAllRules();
288: assertEquals(1, list.size());
289:
290: workingMemory.insert(bob);
291: workingMemory.fireAllRules();
292: assertEquals(1, list.size());
293: }
294:
295: public void testForall() throws Exception {
296: final PackageBuilder builder = new PackageBuilder();
297: builder.addPackageFromDrl(new InputStreamReader(getClass()
298: .getResourceAsStream("test_Forall.drl")));
299: final Package pkg = builder.getPackage();
300:
301: final RuleBase ruleBase = getRuleBase();
302: ruleBase.addPackage(pkg);
303: final WorkingMemory workingMemory = ruleBase
304: .newStatefulSession();
305:
306: final List list = new ArrayList();
307: workingMemory.setGlobal("results", list);
308:
309: final State state = new State("SP");
310: workingMemory.insert(state);
311:
312: final Person bob = new Person("Bob");
313: bob.setStatus(state.getState());
314: bob.setLikes("stilton");
315: workingMemory.insert(bob);
316:
317: workingMemory.fireAllRules();
318:
319: assertEquals(0, list.size());
320:
321: workingMemory.insert(new Cheese(bob.getLikes(), 10));
322: workingMemory.fireAllRules();
323:
324: assertEquals(1, list.size());
325: }
326:
327: public void testRemoveIdentitiesSubNetwork() throws Exception {
328: final PackageBuilder builder = new PackageBuilder();
329: builder.addPackageFromDrl(new InputStreamReader(getClass()
330: .getResourceAsStream(
331: "test_removeIdentitiesSubNetwork.drl")));
332: final Package pkg = builder.getPackage();
333:
334: final RuleBaseConfiguration config = new RuleBaseConfiguration();
335: config.setRemoveIdentities(true);
336: final RuleBase ruleBase = getRuleBase(config);
337: ruleBase.addPackage(pkg);
338: final WorkingMemory workingMemory = ruleBase
339: .newStatefulSession();
340:
341: final List list = new ArrayList();
342: workingMemory.setGlobal("results", list);
343:
344: final Person bob = new Person("bob", "stilton");
345: workingMemory.insert(bob);
346:
347: final Person mark = new Person("mark", "stilton");
348: workingMemory.insert(mark);
349:
350: final Cheese stilton1 = new Cheese("stilton", 6);
351: final FactHandle stilton1Handle = workingMemory
352: .insert(stilton1);
353: final Cheese stilton2 = new Cheese("stilton", 7);
354: final FactHandle stilton2Handle = workingMemory
355: .insert(stilton2);
356:
357: workingMemory.fireAllRules();
358: assertEquals(0, list.size());
359:
360: workingMemory.retract(stilton1Handle);
361:
362: workingMemory.fireAllRules();
363: assertEquals(1, list.size());
364: assertEquals(mark, list.get(0));
365:
366: workingMemory.retract(stilton2Handle);
367:
368: workingMemory.fireAllRules();
369: assertEquals(2, list.size());
370: assertEquals(bob, list.get(1));
371: }
372:
373: public void testCollectWithNestedFromWithParams() throws Exception {
374: final PackageBuilder builder = new PackageBuilder();
375: builder
376: .addPackageFromDrl(new InputStreamReader(getClass()
377: .getResourceAsStream(
378: "test_CollectWithNestedFrom.drl")));
379: final Package pkg = builder.getPackage();
380:
381: final RuleBase ruleBase = getRuleBase();
382: ruleBase.addPackage(pkg);
383:
384: final WorkingMemory workingMemory = ruleBase
385: .newStatefulSession();
386: final List results = new ArrayList();
387: workingMemory.setGlobal("results", results);
388:
389: final Person bob = new Person("bob", "stilton");
390:
391: Cheesery cheesery = new Cheesery();
392: cheesery.addCheese(new Cheese("stilton", 10));
393: cheesery.addCheese(new Cheese("brie", 20));
394: cheesery.addCheese(new Cheese("muzzarela", 8));
395: cheesery.addCheese(new Cheese("stilton", 5));
396: cheesery.addCheese(new Cheese("provolone", 1));
397:
398: workingMemory.insert(bob);
399: workingMemory.insert(cheesery);
400:
401: workingMemory.fireAllRules();
402:
403: assertEquals(1, results.size());
404: List cheeses = (List) results.get(0);
405: assertEquals(2, cheeses.size());
406: assertEquals(bob.getLikes(), ((Cheese) cheeses.get(0))
407: .getType());
408: assertEquals(bob.getLikes(), ((Cheese) cheeses.get(1))
409: .getType());
410:
411: }
412:
413: public void testCollectModifyAlphaRestriction() throws Exception {
414: // read in the source
415: final Reader reader = new InputStreamReader(
416: getClass().getResourceAsStream(
417: "test_CollectAlphaRestriction.drl"));
418: final RuleBase ruleBase = loadRuleBase(reader);
419:
420: final WorkingMemory wm = ruleBase.newStatefulSession();
421: final List results = new ArrayList();
422:
423: wm.setGlobal("results", results);
424:
425: final Cheese[] cheese = new Cheese[] {
426: new Cheese("stilton", 10), new Cheese("stilton", 2),
427: new Cheese("stilton", 5), new Cheese("brie", 15),
428: new Cheese("brie", 16), new Cheese("provolone", 8) };
429:
430: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
431: for (int i = 0; i < cheese.length; i++) {
432: cheeseHandles[i] = wm.insert(cheese[i]);
433: }
434:
435: // ---------------- 1st scenario
436: int fireCount = 0;
437: wm.fireAllRules();
438: Assert.assertEquals(++fireCount, results.size());
439: Assert.assertEquals(3,
440: ((Collection) results.get(fireCount - 1)).size());
441: Assert.assertEquals(ArrayList.class.getName(), results.get(
442: fireCount - 1).getClass().getName());
443:
444: // ---------------- 2nd scenario
445: final int index = 1;
446: cheese[index].setType("brie");
447: wm.update(cheeseHandles[index], cheese[index]);
448: wm.fireAllRules();
449:
450: Assert.assertEquals(++fireCount, results.size());
451: Assert.assertEquals(2,
452: ((Collection) results.get(fireCount - 1)).size());
453: Assert.assertEquals(ArrayList.class.getName(), results.get(
454: fireCount - 1).getClass().getName());
455:
456: // ---------------- 3rd scenario
457: wm.retract(cheeseHandles[2]);
458: wm.fireAllRules();
459:
460: Assert.assertEquals(++fireCount, results.size());
461: Assert.assertEquals(1,
462: ((Collection) results.get(fireCount - 1)).size());
463: Assert.assertEquals(ArrayList.class.getName(), results.get(
464: fireCount - 1).getClass().getName());
465:
466: }
467:
468: private RuleBase loadRuleBase(final Reader reader)
469: throws IOException, DroolsParserException, Exception {
470: final DrlParser parser = new DrlParser();
471: final PackageDescr packageDescr = parser.parse(reader);
472: if (parser.hasErrors()) {
473: System.out.println(parser.getErrors());
474: Assert
475: .fail("Error messages in parser, need to sort this our (or else collect error messages)");
476: }
477: // pre build the package
478: final PackageBuilder builder = new PackageBuilder();
479: builder.addPackage(packageDescr);
480: final Package pkg = builder.getPackage();
481:
482: // add the package to a rulebase
483: final RuleBase ruleBase = getRuleBase();
484: ruleBase.addPackage(pkg);
485: // load up the rulebase
486: return ruleBase;
487: }
488:
489: public void testForallSinglePattern() throws Exception {
490: final PackageBuilder builder = new PackageBuilder();
491: builder.addPackageFromDrl(new InputStreamReader(getClass()
492: .getResourceAsStream("test_ForallSinglePattern.drl")));
493: final Package pkg = builder.getPackage();
494:
495: final RuleBase ruleBase = getRuleBase();
496: ruleBase.addPackage(pkg);
497: final WorkingMemory workingMemory = ruleBase
498: .newStatefulSession();
499:
500: final List list = new ArrayList();
501: workingMemory.setGlobal("results", list);
502:
503: // no cheeses, so should fire
504: workingMemory.fireAllRules();
505: assertEquals(1, list.size());
506:
507: // only stilton, so should not fire again
508: FactHandle stilton1 = workingMemory.insert(new Cheese(
509: "stilton", 10));
510: workingMemory.fireAllRules();
511: assertEquals(1, list.size());
512:
513: // only stilton, so should fire again
514: FactHandle stilton2 = workingMemory.insert(new Cheese(
515: "stilton", 11));
516: workingMemory.fireAllRules();
517: assertEquals(1, list.size());
518:
519: // there is a brie, so should not fire
520: FactHandle brie = workingMemory.insert(new Cheese("brie", 10));
521: workingMemory.fireAllRules();
522: assertEquals(1, list.size());
523:
524: // there is a brie, so should not fire
525: workingMemory.retract(stilton1);
526: workingMemory.fireAllRules();
527: assertEquals(1, list.size());
528:
529: // no brie anymore, so should fire
530: workingMemory.retract(brie);
531: workingMemory.fireAllRules();
532: assertEquals(2, list.size());
533:
534: // TODO: in the future, we need to fix the following test case
535: // // no cheese anymore, so should not fire again
536: // workingMemory.retract( stilton2 );
537: // workingMemory.fireAllRules();
538: // assertEquals( 2,
539: // list.size() );
540: //
541:
542: }
543:
544: public void testMVELCollect() throws Exception {
545:
546: // read in the source
547: final Reader reader = new InputStreamReader(getClass()
548: .getResourceAsStream("test_MVELCollect.drl"));
549: final RuleBase ruleBase = loadRuleBase(reader);
550:
551: final WorkingMemory wm = ruleBase.newStatefulSession();
552: final List results = new ArrayList();
553:
554: wm.setGlobal("results", results);
555:
556: wm.insert(new Cheese("stilton", 10));
557: wm.insert(new Cheese("stilton", 7));
558: wm.insert(new Cheese("stilton", 8));
559: wm.insert(new Cheese("brie", 5));
560: wm.insert(new Cheese("provolone", 150));
561: wm.insert(new Cheese("provolone", 20));
562: wm.insert(new Person("Bob", "stilton"));
563: wm.insert(new Person("Mark", "provolone"));
564:
565: wm.fireAllRules();
566:
567: Assert.assertEquals(1, results.size());
568: Assert.assertEquals(6, ((List) results.get(0)).size());
569: }
570:
571: public void testNestedCorelatedRulesWithForall() throws Exception {
572:
573: PackageBuilder builder = new PackageBuilder();
574: builder
575: .addPackageFromDrl(new InputStreamReader(
576: FirstOrderLogicTest.class
577: .getResourceAsStream("test_NestedCorrelatedRulesWithForall.drl")));
578:
579: RuleBase rb = RuleBaseFactory.newRuleBase();
580: rb.addPackage(builder.getPackage());
581: StatefulSession session = rb.newStatefulSession();
582:
583: List list1 = new ArrayList();
584: List list2 = new ArrayList();
585: List list3 = new ArrayList();
586: List list4 = new ArrayList();
587:
588: session.setGlobal("list1", list1);
589: session.setGlobal("list2", list2);
590: session.setGlobal("list3", list3);
591: session.setGlobal("list4", list4);
592:
593: SpecialString first42 = new SpecialString("42");
594: SpecialString second42 = new SpecialString("42");
595: SpecialString world = new SpecialString("World");
596:
597: //System.out.println( "Inserting ..." );
598:
599: session.insert(world);
600: session.insert(first42);
601: session.insert(second42);
602:
603: //System.out.println( "Done." );
604:
605: //System.out.println( "Firing rules ..." );
606:
607: // check all lists are empty
608: assertTrue(list1.isEmpty());
609: assertTrue(list2.isEmpty());
610: assertTrue(list3.isEmpty());
611: assertTrue(list4.isEmpty());
612:
613: session.fireAllRules();
614:
615: //System.out.println( "Done." );
616:
617: // check first list is populated correctly
618: assertEquals(0, list1.size());
619:
620: // check second list is populated correctly
621: assertEquals(0, list2.size());
622:
623: // check third list is populated correctly
624: assertEquals(1, list3.size());
625:
626: // check fourth list is populated correctly
627: assertEquals(0, list4.size());
628: }
629:
630: public void testFromInsideNotAndExists() throws Exception {
631: final PackageBuilder builder = new PackageBuilder();
632: builder
633: .addPackageFromDrl(new InputStreamReader(getClass()
634: .getResourceAsStream(
635: "test_FromInsideNotAndExists.drl")));
636: final Package pkg = builder.getPackage();
637:
638: final RuleBase ruleBase = getRuleBase();
639: ruleBase.addPackage(pkg);
640: final WorkingMemory workingMemory = ruleBase
641: .newStatefulSession();
642:
643: final List list = new ArrayList();
644: workingMemory.setGlobal("results", list);
645:
646: final Cheese cheddar = new Cheese("cheddar", 7);
647: final Cheese provolone = new Cheese("provolone", 5);
648: final Cheesery cheesery = new Cheesery();
649:
650: cheesery.addCheese(cheddar);
651: cheesery.addCheese(provolone);
652:
653: FactHandle handle = workingMemory.insert(cheesery);
654: workingMemory.fireAllRules();
655: assertEquals(0, list.size());
656:
657: cheesery.addCheese(new Cheese("stilton", 10));
658: cheesery.removeCheese(cheddar);
659: workingMemory.update(handle, cheesery);
660: workingMemory.fireAllRules();
661: assertEquals(2, list.size());
662:
663: }
664:
665: }
|