001: package org.drools.integrationtests;
002:
003: import java.io.InputStreamReader;
004: import java.io.Reader;
005: import java.util.ArrayList;
006: import java.util.List;
007:
008: import junit.framework.TestCase;
009:
010: import org.drools.Cheese;
011: import org.drools.CheeseEqual;
012: import org.drools.FactHandle;
013: import org.drools.Person;
014: import org.drools.RuleBase;
015: import org.drools.RuleBaseConfiguration;
016: import org.drools.RuleBaseFactory;
017: import org.drools.Sensor;
018: import org.drools.WorkingMemory;
019: import org.drools.base.ClassObjectFilter;
020: import org.drools.common.InternalWorkingMemory;
021: import org.drools.common.TruthMaintenanceSystem;
022: import org.drools.compiler.PackageBuilder;
023: import org.drools.event.DefaultWorkingMemoryEventListener;
024: import org.drools.event.ObjectInsertedEvent;
025: import org.drools.event.ObjectRetractedEvent;
026: import org.drools.event.ObjectUpdatedEvent;
027: import org.drools.event.WorkingMemoryEventListener;
028: import org.drools.rule.Package;
029: import org.drools.util.ObjectHashMap;
030:
031: public class TruthMaintenanceTest extends TestCase {
032: protected RuleBase getRuleBase() throws Exception {
033:
034: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, null);
035: }
036:
037: protected RuleBase getRuleBase(final RuleBaseConfiguration config)
038: throws Exception {
039:
040: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, config);
041: }
042:
043: public void testLogicalInsertions() throws Exception {
044: final PackageBuilder builder = new PackageBuilder();
045: builder.addPackageFromDrl(new InputStreamReader(getClass()
046: .getResourceAsStream("test_LogicalInsertions.drl")));
047: final Package pkg = builder.getPackage();
048:
049: final RuleBase ruleBase = getRuleBase();
050: ruleBase.addPackage(pkg);
051: final WorkingMemory workingMemory = ruleBase
052: .newStatefulSession();
053:
054: final List list = new ArrayList();
055: workingMemory.setGlobal("list", list);
056:
057: final Cheese brie = new Cheese("brie", 12);
058: final FactHandle brieHandle = workingMemory.insert(brie);
059:
060: final Cheese provolone = new Cheese("provolone", 12);
061: final FactHandle provoloneHandle = workingMemory
062: .insert(provolone);
063:
064: workingMemory.fireAllRules();
065:
066: assertEquals(3, list.size());
067:
068: assertEquals(3, IteratorToList.convert(
069: workingMemory.iterateObjects()).size());
070:
071: workingMemory.retract(brieHandle);
072:
073: assertEquals(2, IteratorToList.convert(
074: workingMemory.iterateObjects()).size());
075:
076: workingMemory.retract(provoloneHandle);
077:
078: assertEquals(0, IteratorToList.convert(
079: workingMemory.iterateObjects()).size());
080: }
081:
082: public void testLogicalInsertionsBacking() throws Exception {
083: final PackageBuilder builder = new PackageBuilder();
084: builder.addPackageFromDrl(new InputStreamReader(getClass()
085: .getResourceAsStream(
086: "test_LogicalInsertionsBacking.drl")));
087: final Package pkg = builder.getPackage();
088:
089: final RuleBase ruleBase = getRuleBase();
090: ruleBase.addPackage(pkg);
091: final WorkingMemory workingMemory = ruleBase
092: .newStatefulSession();
093:
094: final Cheese cheese1 = new Cheese("c", 1);
095: final Cheese cheese2 = new Cheese(cheese1.getType(), 1);
096: List list;
097:
098: final FactHandle h1 = workingMemory.insert(cheese1);
099: workingMemory.fireAllRules();
100: list = IteratorToList.convert(workingMemory
101: .iterateObjects(new ClassObjectFilter(cheese1.getType()
102: .getClass())));
103: assertEquals(1, list.size());
104: // probably dangerous, as contains works with equals, not identity
105: assertEquals(cheese1.getType(), list.get(0));
106: // FactHandle ht = workingMemory.getFactHandle(c1.getType());
107:
108: final FactHandle h2 = workingMemory.insert(cheese2);
109: workingMemory.fireAllRules();
110: list = IteratorToList.convert(workingMemory
111: .iterateObjects(new ClassObjectFilter(cheese1.getType()
112: .getClass())));
113: assertEquals(1, list.size());
114: assertEquals(cheese1.getType(), list.get(0));
115:
116: assertEquals(3, IteratorToList.convert(
117: workingMemory.iterateObjects()).size());
118:
119: workingMemory.retract(h1);
120: workingMemory.fireAllRules();
121: list = IteratorToList.convert(workingMemory
122: .iterateObjects(new ClassObjectFilter(cheese1.getType()
123: .getClass())));
124: assertEquals(
125: "cheese-type "
126: + cheese1.getType()
127: + " was retracted, but should not. Backed by cheese2 => type.",
128: 1, list.size());
129: assertEquals(
130: "cheese-type "
131: + cheese1.getType()
132: + " was retracted, but should not. Backed by cheese2 => type.",
133: cheese1.getType(), list.get(0));
134:
135: workingMemory.retract(h2);
136: workingMemory.fireAllRules();
137: list = IteratorToList.convert(workingMemory
138: .iterateObjects(new ClassObjectFilter(cheese1.getType()
139: .getClass())));
140: assertEquals(
141: "cheese-type "
142: + cheese1.getType()
143: + " was not retracted, but should have. Neither cheese1 => type nor cheese2 => type is true.",
144: 0, list.size());
145: }
146:
147: public void testLogicalInsertionsSelfreferencing() throws Exception {
148: final PackageBuilder builder = new PackageBuilder();
149: builder.addPackageFromDrl(new InputStreamReader(getClass()
150: .getResourceAsStream(
151: "test_LogicalInsertionsSelfreferencing.drl")));
152: final Package pkg = builder.getPackage();
153:
154: final RuleBase ruleBase = getRuleBase();
155: ruleBase.addPackage(pkg);
156: final WorkingMemory workingMemory = ruleBase
157: .newStatefulSession();
158:
159: List list;
160:
161: final Person b = new Person("b");
162: final Person a = new Person("a");
163:
164: workingMemory.setGlobal("b", b);
165:
166: FactHandle h1 = workingMemory.insert(a);
167: workingMemory.fireAllRules();
168: list = IteratorToList.convert(workingMemory
169: .iterateObjects(new ClassObjectFilter(a.getClass())));
170: assertEquals(2, list.size());
171: assertTrue(list.contains(a));
172: assertTrue(list.contains(b));
173:
174: workingMemory.retract(h1);
175: workingMemory.fireAllRules();
176: list = IteratorToList.convert(workingMemory
177: .iterateObjects(new ClassObjectFilter(a.getClass())));
178: assertEquals(
179: "b was retracted, but it should not have. Is backed by b => b being true.",
180: 1, list.size());
181: assertEquals(
182: "b was retracted, but it should not have. Is backed by b => b being true.",
183: b, list.get(0));
184:
185: h1 = workingMemory.getFactHandle(b);
186: workingMemory.retract(h1);
187: workingMemory.fireAllRules();
188: list = IteratorToList.convert(workingMemory
189: .iterateObjects(new ClassObjectFilter(a.getClass())));
190: assertEquals(0, list.size());
191: }
192:
193: public void testLogicalInsertionsLoop() throws Exception {
194: final PackageBuilder builder = new PackageBuilder();
195: builder
196: .addPackageFromDrl(new InputStreamReader(getClass()
197: .getResourceAsStream(
198: "test_LogicalInsertionsLoop.drl")));
199: final Package pkg = builder.getPackage();
200:
201: final RuleBase ruleBase = getRuleBase();
202: ruleBase.addPackage(pkg);
203: final WorkingMemory workingMemory = ruleBase
204: .newStatefulSession();
205:
206: List list;
207:
208: final List l = new ArrayList();
209: final Person a = new Person("a");
210: workingMemory.setGlobal("a", a);
211: workingMemory.setGlobal("l", l);
212:
213: workingMemory.fireAllRules();
214: list = IteratorToList.convert(workingMemory
215: .iterateObjects(new ClassObjectFilter(a.getClass())));
216: assertEquals("a still asserted.", 0, list.size());
217: assertEquals(
218: "Rule has not fired (looped) expected number of times",
219: 10, l.size());
220: }
221:
222: public void testLogicalInsertionsNoLoop() throws Exception {
223: final PackageBuilder builder = new PackageBuilder();
224: builder.addPackageFromDrl(new InputStreamReader(
225: getClass().getResourceAsStream(
226: "test_LogicalInsertionsNoLoop.drl")));
227: final Package pkg = builder.getPackage();
228:
229: final RuleBase ruleBase = getRuleBase();
230: ruleBase.addPackage(pkg);
231: final WorkingMemory workingMemory = ruleBase
232: .newStatefulSession();
233:
234: List list;
235:
236: final List l = new ArrayList();
237: final Person a = new Person("a");
238: workingMemory.setGlobal("a", a);
239: workingMemory.setGlobal("l", l);
240:
241: workingMemory.fireAllRules();
242: list = IteratorToList.convert(workingMemory
243: .iterateObjects(new ClassObjectFilter(a.getClass())));
244: assertEquals("a still in WM", 0, list.size());
245: assertEquals("Rule should not loop", 1, l.size());
246: }
247:
248: public void testLogicalInsertionsWithModify() throws Exception {
249: final PackageBuilder builder = new PackageBuilder();
250: builder.addPackageFromDrl(new InputStreamReader(getClass()
251: .getResourceAsStream(
252: "test_LogicalInsertionsWithUpdate.drl")));
253: final Package pkg = builder.getPackage();
254:
255: final RuleBase ruleBase = getRuleBase();
256: ruleBase.addPackage(pkg);
257: final WorkingMemory workingMemory = ruleBase
258: .newStatefulSession();
259:
260: final WorkingMemoryEventListener l2 = new DefaultWorkingMemoryEventListener() {
261: public void objectInserted(ObjectInsertedEvent event) {
262: System.out.println(event);
263: }
264:
265: public void objectRetracted(ObjectRetractedEvent event) {
266: System.out.println(event);
267: }
268:
269: public void objectUpdated(ObjectUpdatedEvent event) {
270: System.out.println(event);
271: }
272: };
273:
274: workingMemory.addEventListener(l2);
275:
276: List l;
277: final Person p = new Person("person");
278: p.setAge(2);
279: final FactHandle h = workingMemory.insert(p);
280: assertEquals(1, IteratorToList.convert(
281: workingMemory.iterateObjects()).size());
282:
283: workingMemory.fireAllRules();
284: assertEquals(2, IteratorToList.convert(
285: workingMemory.iterateObjects()).size());
286:
287: l = IteratorToList
288: .convert(workingMemory
289: .iterateObjects(new ClassObjectFilter(
290: CheeseEqual.class)));
291: assertEquals(1, l.size());
292: assertEquals(2, ((CheeseEqual) l.get(0)).getPrice());
293:
294: workingMemory.retract(h);
295: assertEquals(0, IteratorToList.convert(
296: workingMemory.iterateObjects()).size());
297:
298: TruthMaintenanceSystem tms = ((InternalWorkingMemory) workingMemory)
299: .getTruthMaintenanceSystem();
300:
301: final java.lang.reflect.Field field = tms.getClass()
302: .getDeclaredField("assertMap");
303: field.setAccessible(true);
304: final ObjectHashMap m = (ObjectHashMap) field.get(tms);
305: field.setAccessible(false);
306: assertEquals("assertMap should be empty", 0, m.size());
307: }
308:
309: public void testLogicalInsertions2() throws Exception {
310: final PackageBuilder builder = new PackageBuilder();
311: builder.addPackageFromDrl(new InputStreamReader(getClass()
312: .getResourceAsStream("test_LogicalInsertions2.drl")));
313: final Package pkg = builder.getPackage();
314:
315: final RuleBase ruleBase = getRuleBase();
316: ruleBase.addPackage(pkg);
317: final WorkingMemory workingMemory = ruleBase
318: .newStatefulSession();
319:
320: // final WorkingMemoryFileLogger logger = new WorkingMemoryFileLogger( workingMemory );
321: // logger.setFileName( "logical" );
322:
323: final List events = new ArrayList();
324:
325: workingMemory.setGlobal("events", events);
326:
327: final Sensor sensor = new Sensor(80, 80);
328: final FactHandle handle = workingMemory.insert(sensor);
329:
330: // everything should be normal
331: workingMemory.fireAllRules();
332:
333: final List list = IteratorToList.convert(workingMemory
334: .iterateObjects());
335:
336: assertEquals("Only sensor is there", 1, list.size());
337: assertEquals("Only one event", 1, events.size());
338:
339: // problems should be detected
340: sensor.setPressure(200);
341: sensor.setTemperature(200);
342: workingMemory.update(handle, sensor);
343:
344: workingMemory.fireAllRules();
345: // logger.writeToDisk();
346:
347: assertEquals("Only sensor is there", 1, list.size());
348: assertEquals("Exactly seven events", 7, events.size());
349: }
350:
351: public void testLogicalInsertionsNot() throws Exception {
352: final PackageBuilder builder = new PackageBuilder();
353: builder.addPackageFromDrl(new InputStreamReader(getClass()
354: .getResourceAsStream("test_LogicalInsertionsNot.drl")));
355: final Package pkg = builder.getPackage();
356:
357: final RuleBase ruleBase = getRuleBase();
358: ruleBase.addPackage(pkg);
359: final WorkingMemory workingMemory = ruleBase
360: .newStatefulSession();
361:
362: List list;
363:
364: final Person a = new Person("a");
365: final Cheese cheese = new Cheese("brie", 1);
366: workingMemory.setGlobal("cheese", cheese);
367:
368: workingMemory.fireAllRules();
369: list = IteratorToList.convert(workingMemory.iterateObjects());
370: assertEquals("i was not asserted by not a => i.", 1, list
371: .size());
372: assertEquals("i was not asserted by not a => i.", cheese, list
373: .get(0));
374:
375: final FactHandle h = workingMemory.insert(a);
376: // no need to fire rules, assertion alone removes justification for i,
377: // so it should be retracted.
378: // workingMemory.fireAllRules();
379: list = IteratorToList.convert(workingMemory.iterateObjects());
380: assertEquals("a was not asserted or i not retracted.", 1, list
381: .size());
382: assertEquals("a was asserted.", a, list.get(0));
383: assertFalse("i was not rectracted.", list.contains(cheese));
384:
385: // no rules should fire, but nevertheless...
386: // workingMemory.fireAllRules();
387: assertEquals("agenda should be empty.", 0, workingMemory
388: .getAgenda().agendaSize());
389:
390: workingMemory.retract(h);
391: workingMemory.fireAllRules();
392: list = IteratorToList.convert(workingMemory.iterateObjects());
393: assertEquals("i was not asserted by not a => i.", 1, list
394: .size());
395: assertEquals("i was not asserted by not a => i.", cheese, list
396: .get(0));
397: }
398:
399: public void testLogicalInsertionsNotPingPong() throws Exception {
400: final PackageBuilder builder = new PackageBuilder();
401: builder.addPackageFromDrl(new InputStreamReader(getClass()
402: .getResourceAsStream(
403: "test_LogicalInsertionsNotPingPong.drl")));
404: final Package pkg = builder.getPackage();
405:
406: final RuleBase ruleBase = getRuleBase();
407: ruleBase.addPackage(pkg);
408: final WorkingMemory workingMemory = ruleBase
409: .newStatefulSession();
410:
411: // workingMemory.addEventListener(new DebugAgendaEventListener());
412: // workingMemory.addEventListener(new
413: // DebugWorkingMemoryEventListener());
414:
415: final List list = new ArrayList();
416:
417: final Person person = new Person("person");
418: final Cheese cheese = new Cheese("cheese", 0);
419: workingMemory.setGlobal("cheese", cheese);
420: workingMemory.setGlobal("person", person);
421: workingMemory.setGlobal("list", list);
422:
423: workingMemory.fireAllRules();
424:
425: // not sure about desired state of working memory.
426: assertEquals(
427: "Rules have not fired (looped) expected number of times",
428: 10, list.size());
429: }
430:
431: public void testLogicalInsertionsDynamicRule() throws Exception {
432: PackageBuilder builder = new PackageBuilder();
433: builder.addPackageFromDrl(new InputStreamReader(getClass()
434: .getResourceAsStream(
435: "test_LogicalInsertionsDynamicRule.drl")));
436: final Package pkg = builder.getPackage();
437:
438: org.drools.reteoo.ReteooRuleBase reteooRuleBase = null;
439: // org.drools.leaps.LeapsRuleBase leapsRuleBase = null;
440: final RuleBase ruleBase = getRuleBase();
441: if (ruleBase instanceof org.drools.reteoo.ReteooRuleBase) {
442: reteooRuleBase = (org.drools.reteoo.ReteooRuleBase) ruleBase;
443: // } else if ( ruleBase instanceof org.drools.leaps.LeapsRuleBase )
444: // {
445: // leapsRuleBase = (org.drools.leaps.LeapsRuleBase) ruleBase;
446: }
447: ruleBase.addPackage(pkg);
448: final WorkingMemory workingMemory = ruleBase
449: .newStatefulSession();
450:
451: // workingMemory.addEventListener(new
452: // org.drools.event.DebugAgendaEventListener());
453: // workingMemory.addEventListener(new
454: // org.drools.event.DebugWorkingMemoryEventListener());
455:
456: final Cheese c1 = new Cheese("a", 1);
457: final Cheese c2 = new Cheese("b", 2);
458: final Cheese c3 = new Cheese("c", 3);
459: List list;
460:
461: workingMemory.insert(c1);
462: final FactHandle h = workingMemory.insert(c2);
463: workingMemory.insert(c3);
464: workingMemory.fireAllRules();
465:
466: // Check logical Insertions where made for c2 and c3
467: list = IteratorToList.convert(workingMemory
468: .iterateObjects(new ClassObjectFilter(Person.class)));
469: assertEquals(2, list.size());
470: assertFalse(list.contains(new Person(c1.getType())));
471: assertTrue(list.contains(new Person(c2.getType())));
472: assertTrue(list.contains(new Person(c3.getType())));
473:
474: // this rule will make a logical assertion for c1 too
475: final Reader reader = new InputStreamReader(getClass()
476: .getResourceAsStream(
477: "test_LogicalInsertionsDynamicRule2.drl"));
478: builder = new PackageBuilder();
479: builder.addPackageFromDrl(reader);
480: final Package pkg2 = builder.getPackage();
481: ruleBase.addPackage(pkg2);
482:
483: workingMemory.fireAllRules();
484:
485: // check all now have just one logical assertion each
486: list = IteratorToList.convert(workingMemory
487: .iterateObjects(new ClassObjectFilter(Person.class)));
488: assertEquals(3, list.size());
489: assertTrue(list.contains(new Person(c1.getType())));
490: assertTrue(list.contains(new Person(c2.getType())));
491: assertTrue(list.contains(new Person(c3.getType())));
492:
493: // check the packages are correctly populated
494: assertEquals("org.drools.test", ruleBase.getPackages()[0]
495: .getName());
496: assertEquals("org.drools.test2", ruleBase.getPackages()[1]
497: .getName());
498: assertEquals("rule1", ruleBase.getPackages()[0].getRules()[0]
499: .getName());
500: assertEquals("rule2", ruleBase.getPackages()[1].getRules()[0]
501: .getName());
502:
503: // now remove the first rule
504: if (reteooRuleBase != null) {
505: reteooRuleBase.removeRule(ruleBase.getPackages()[0]
506: .getName(), ruleBase.getPackages()[0].getRules()[0]
507: .getName());
508: // } else if ( leapsRuleBase != null ) {
509: // leapsRuleBase.removeRule( ruleBase.getPackages()[0].getName(),
510: // ruleBase.getPackages()[0].getRules()[0].getName() );
511: }
512:
513: // Check the rule was correctly remove
514: assertEquals(0, ruleBase.getPackages()[0].getRules().length);
515: assertEquals(1, ruleBase.getPackages()[1].getRules().length);
516: assertEquals("org.drools.test2", ruleBase.getPackages()[1]
517: .getName());
518: assertEquals("rule2", ruleBase.getPackages()[1].getRules()[0]
519: .getName());
520:
521: list = IteratorToList.convert(workingMemory
522: .iterateObjects(new ClassObjectFilter(Person.class)));
523: assertEquals(
524: "removal of the rule should result in retraction of c3's logical assertion",
525: 2, list.size());
526: assertTrue("c1's logical assertion should not be retracted",
527: list.contains(new Person(c1.getType())));
528: assertTrue("c2's logical assertion should not be retracted",
529: list.contains(new Person(c2.getType())));
530: assertFalse("c3's logical assertion should be retracted", list
531: .contains(new Person(c3.getType())));
532:
533: c2.setPrice(3);
534: workingMemory.update(h, c2);
535: list = IteratorToList.convert(workingMemory
536: .iterateObjects(new ClassObjectFilter(Person.class)));
537: assertEquals(
538: "c2 now has a higher price, its logical assertion should be cancelled",
539: 1, list.size());
540: assertFalse(
541: "The logical assertion cor c2 should have been retracted",
542: list.contains(new Person(c2.getType())));
543: assertTrue("The logical assertion for c1 should exist", list
544: .contains(new Person(c1.getType())));
545:
546: if (reteooRuleBase != null) {
547: reteooRuleBase.removeRule(ruleBase.getPackages()[1]
548: .getName(), ruleBase.getPackages()[1].getRules()[0]
549: .getName());
550: // } else if ( leapsRuleBase != null ) {
551: // leapsRuleBase.removeRule( ruleBase.getPackages()[1].getName(),
552: // ruleBase.getPackages()[1].getRules()[0].getName() );
553: }
554: assertEquals(0, ruleBase.getPackages()[0].getRules().length);
555: assertEquals(0, ruleBase.getPackages()[1].getRules().length);
556: list = IteratorToList.convert(workingMemory
557: .iterateObjects(new ClassObjectFilter(Person.class)));
558: assertEquals(0, list.size());
559: }
560:
561: public void testLogicalInsertionsUpdateEqual() throws Exception {
562: final PackageBuilder builder = new PackageBuilder();
563: builder.addPackageFromDrl(new InputStreamReader(getClass()
564: .getResourceAsStream(
565: "test_LogicalInsertionsUpdateEqual.drl")));
566: final Package pkg = builder.getPackage();
567:
568: final RuleBase ruleBase = getRuleBase();
569: ruleBase.addPackage(pkg);
570: final WorkingMemory workingMemory = ruleBase
571: .newStatefulSession();
572:
573: List l;
574: final Person p = new Person("person");
575: p.setAge(2);
576: final FactHandle h = workingMemory.insert(p);
577: assertEquals(1, IteratorToList.convert(
578: workingMemory.iterateObjects()).size());
579:
580: workingMemory.fireAllRules();
581: assertEquals(2, IteratorToList.convert(
582: workingMemory.iterateObjects()).size());
583: l = IteratorToList
584: .convert(workingMemory
585: .iterateObjects(new ClassObjectFilter(
586: CheeseEqual.class)));
587: assertEquals(1, l.size());
588: assertEquals(3, ((CheeseEqual) l.get(0)).getPrice());
589:
590: workingMemory.retract(h);
591: assertEquals(0, IteratorToList.convert(
592: workingMemory.iterateObjects()).size());
593:
594: TruthMaintenanceSystem tms = ((InternalWorkingMemory) workingMemory)
595: .getTruthMaintenanceSystem();
596:
597: final java.lang.reflect.Field field = tms.getClass()
598: .getDeclaredField("assertMap");
599: field.setAccessible(true);
600: final ObjectHashMap m = (ObjectHashMap) field.get(tms);
601: field.setAccessible(false);
602: assertEquals("assertMap should be empty", 0, m.size());
603: }
604:
605: public void testLogicalInsertionsWithExists() throws Exception {
606: final PackageBuilder builder = new PackageBuilder();
607: builder.addPackageFromDrl(new InputStreamReader(getClass()
608: .getResourceAsStream(
609: "test_LogicalInsertionWithExists.drl")));
610: final Package pkg = builder.getPackage();
611:
612: final RuleBase ruleBase = getRuleBase();
613: ruleBase.addPackage(pkg);
614: final WorkingMemory workingMemory = ruleBase
615: .newStatefulSession();
616:
617: final Person p1 = new Person("p1", "stilton", 20);
618: p1.setStatus("europe");
619: final FactHandle c1FactHandle = workingMemory.insert(p1);
620: final Person p2 = new Person("p2", "stilton", 30);
621: p2.setStatus("europe");
622: final FactHandle c2FactHandle = workingMemory.insert(p2);
623: final Person p3 = new Person("p3", "stilton", 40);
624: p3.setStatus("europe");
625: final FactHandle c3FactHandle = workingMemory.insert(p3);
626: workingMemory.fireAllRules();
627:
628: // all 3 in europe, so, 2 cheese
629: List cheeseList = IteratorToList.convert(workingMemory
630: .iterateObjects(new ClassObjectFilter(Cheese.class)));
631: assertEquals(2, cheeseList.size());
632:
633: // europe=[ 1, 2 ], america=[ 3 ]
634: p3.setStatus("america");
635: workingMemory.update(c3FactHandle, p3);
636: workingMemory.fireAllRules();
637: cheeseList = IteratorToList.convert(workingMemory
638: .iterateObjects(new ClassObjectFilter(Cheese.class)));
639: assertEquals(1, cheeseList.size());
640:
641: // europe=[ 1 ], america=[ 2, 3 ]
642: p2.setStatus("america");
643: workingMemory.update(c2FactHandle, p2);
644: workingMemory.fireAllRules();
645: cheeseList = IteratorToList.convert(workingMemory
646: .iterateObjects(new ClassObjectFilter(Cheese.class)));
647: assertEquals(1, cheeseList.size());
648:
649: // europe=[ ], america=[ 1, 2, 3 ]
650: p1.setStatus("america");
651: workingMemory.update(c1FactHandle, p1);
652: workingMemory.fireAllRules();
653: cheeseList = IteratorToList.convert(workingMemory
654: .iterateObjects(new ClassObjectFilter(Cheese.class)));
655: assertEquals(2, cheeseList.size());
656:
657: // europe=[ 2 ], america=[ 1, 3 ]
658: p2.setStatus("europe");
659: workingMemory.update(c2FactHandle, p2);
660: workingMemory.fireAllRules();
661: cheeseList = IteratorToList.convert(workingMemory
662: .iterateObjects(new ClassObjectFilter(Cheese.class)));
663: assertEquals(1, cheeseList.size());
664:
665: // europe=[ 1, 2 ], america=[ 3 ]
666: p1.setStatus("europe");
667: workingMemory.update(c1FactHandle, p1);
668: workingMemory.fireAllRules();
669: cheeseList = IteratorToList.convert(workingMemory
670: .iterateObjects(new ClassObjectFilter(Cheese.class)));
671: assertEquals(1, cheeseList.size());
672:
673: // europe=[ 1, 2, 3 ], america=[ ]
674: p3.setStatus("europe");
675: workingMemory.update(c3FactHandle, p3);
676: workingMemory.fireAllRules();
677: cheeseList = IteratorToList.convert(workingMemory
678: .iterateObjects(new ClassObjectFilter(Cheese.class)));
679: assertEquals(2, cheeseList.size());
680: }
681:
682: public void testLogicalInsertions3() throws Exception {
683: final PackageBuilder builder = new PackageBuilder();
684: builder.addPackageFromDrl(new InputStreamReader(getClass()
685: .getResourceAsStream("test_logicalInsertions3.drl")));
686: final Package pkg = builder.getPackage();
687:
688: final RuleBase ruleBase = getRuleBase();
689: ruleBase.addPackage(pkg);
690: final WorkingMemory workingMemory = ruleBase
691: .newStatefulSession();
692:
693: final List list = new ArrayList();
694: workingMemory.setGlobal("events", list);
695:
696: // asserting the sensor object
697: final Sensor sensor = new Sensor(150, 100);
698: final FactHandle sensorHandle = workingMemory.insert(sensor);
699:
700: workingMemory.fireAllRules();
701:
702: // alarm must sound
703: assertEquals(2, list.size());
704: assertEquals(2, IteratorToList.convert(
705: workingMemory.iterateObjects()).size());
706:
707: // modifying sensor
708: sensor.setTemperature(125);
709: workingMemory.update(sensorHandle, sensor);
710: workingMemory.fireAllRules();
711:
712: // alarm must continue to sound
713: assertEquals(3, list.size());
714: assertEquals(2, IteratorToList.convert(
715: workingMemory.iterateObjects()).size());
716:
717: // modifying sensor
718: sensor.setTemperature(80);
719: workingMemory.update(sensorHandle, sensor);
720: workingMemory.fireAllRules();
721:
722: // no alarms anymore
723: assertEquals(3, list.size());
724: assertEquals(1, IteratorToList.convert(
725: workingMemory.iterateObjects()).size());
726: }
727:
728: public void testLogicalInsertionsAccumulatorPattern()
729: throws Exception {
730: // JBRULES-449
731: final PackageBuilder builder = new PackageBuilder();
732: builder
733: .addPackageFromDrl(new InputStreamReader(
734: getClass()
735: .getResourceAsStream(
736: "test_LogicalInsertionsAccumulatorPattern.drl")));
737: final Package pkg = builder.getPackage();
738:
739: final RuleBase ruleBase = getRuleBase();
740: ruleBase.addPackage(pkg);
741: final WorkingMemory workingMemory = ruleBase
742: .newStatefulSession();
743:
744: workingMemory.setGlobal("ga", "a");
745: workingMemory.setGlobal("gb", "b");
746: workingMemory.setGlobal("gs", new Short((short) 3));
747:
748: workingMemory.fireAllRules();
749:
750: List l;
751: final FactHandle h = workingMemory.insert(new Integer(6));
752: assertEquals(1, IteratorToList.convert(
753: workingMemory.iterateObjects()).size());
754:
755: workingMemory.fireAllRules();
756: l = IteratorToList
757: .convert(workingMemory
758: .iterateObjects(new ClassObjectFilter(
759: CheeseEqual.class)));
760: assertEquals(
761: "There should be 2 CheeseEqual in Working Memory, 1 justified, 1 stated",
762: 2, l.size());
763: assertEquals(6, IteratorToList.convert(
764: workingMemory.iterateObjects()).size());
765:
766: workingMemory.retract(h);
767: l = IteratorToList
768: .convert(workingMemory
769: .iterateObjects(new ClassObjectFilter(
770: CheeseEqual.class)));
771: assertEquals(
772: "There should be only 1 CheeseEqual in Working Memory, 1 stated (the justified should have been retracted). Check TruthMaintenanceSystem justifiedMap",
773: 1, l.size());
774: l = IteratorToList.convert(workingMemory
775: .iterateObjects(new ClassObjectFilter(Short.class)));
776: assertEquals(1, l.size());
777: assertEquals(2, IteratorToList.convert(
778: workingMemory.iterateObjects()).size());
779:
780: //clean-up
781: workingMemory.fireAllRules();
782: assertEquals(0, IteratorToList.convert(
783: workingMemory.iterateObjects()).size());
784: }
785:
786: }
|