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.List;
008:
009: import junit.framework.Assert;
010: import junit.framework.TestCase;
011:
012: import org.drools.Cheese;
013: import org.drools.Cheesery;
014: import org.drools.FactHandle;
015: import org.drools.OuterClass;
016: import org.drools.Person;
017: import org.drools.RuleBase;
018: import org.drools.RuleBaseConfiguration;
019: import org.drools.RuleBaseFactory;
020: import org.drools.RuntimeDroolsException;
021: import org.drools.WorkingMemory;
022: import org.drools.compiler.DrlParser;
023: import org.drools.compiler.DroolsParserException;
024: import org.drools.compiler.PackageBuilder;
025: import org.drools.lang.descr.PackageDescr;
026: import org.drools.rule.Package;
027:
028: public class AccumulateTest extends TestCase {
029: protected RuleBase getRuleBase() throws Exception {
030:
031: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, null);
032: }
033:
034: protected RuleBase getRuleBase(final RuleBaseConfiguration config)
035: throws Exception {
036:
037: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, config);
038: }
039:
040: private RuleBase loadRuleBase(final Reader reader)
041: throws IOException, DroolsParserException, Exception {
042: final DrlParser parser = new DrlParser();
043: final PackageDescr packageDescr = parser.parse(reader);
044: if (parser.hasErrors()) {
045: System.out.println(parser.getErrors());
046: Assert
047: .fail("Error messages in parser, need to sort this our (or else collect error messages)");
048: }
049: // pre build the package
050: final PackageBuilder builder = new PackageBuilder();
051: builder.addPackage(packageDescr);
052: final Package pkg = builder.getPackage();
053:
054: // add the package to a rulebase
055: final RuleBase ruleBase = getRuleBase();
056: ruleBase.addPackage(pkg);
057: // load up the rulebase
058: return ruleBase;
059: }
060:
061: public void testAccumulateModify() throws Exception {
062: // read in the source
063: final Reader reader = new InputStreamReader(getClass()
064: .getResourceAsStream("test_AccumulateModify.drl"));
065: final RuleBase ruleBase = loadRuleBase(reader);
066:
067: final WorkingMemory wm = ruleBase.newStatefulSession();
068: final List results = new ArrayList();
069:
070: wm.setGlobal("results", results);
071:
072: final Cheese[] cheese = new Cheese[] {
073: new Cheese("stilton", 10), new Cheese("stilton", 2),
074: new Cheese("stilton", 5), new Cheese("brie", 15),
075: new Cheese("brie", 16), new Cheese("provolone", 8) };
076: final Person bob = new Person("Bob", "stilton");
077:
078: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
079: for (int i = 0; i < cheese.length; i++) {
080: cheeseHandles[i] = wm.insert(cheese[i]);
081: }
082: final FactHandle bobHandle = wm.insert(bob);
083:
084: // ---------------- 1st scenario
085: wm.fireAllRules();
086: // no fire, as per rule constraints
087: Assert.assertEquals(0, results.size());
088:
089: // ---------------- 2nd scenario
090: final int index = 1;
091: cheese[index].setPrice(9);
092: wm.update(cheeseHandles[index], cheese[index]);
093: wm.fireAllRules();
094:
095: // 1 fire
096: Assert.assertEquals(1, results.size());
097: Assert.assertEquals(24, ((Cheesery) results
098: .get(results.size() - 1)).getTotalAmount());
099:
100: // ---------------- 3rd scenario
101: bob.setLikes("brie");
102: wm.update(bobHandle, bob);
103: wm.fireAllRules();
104:
105: // 2 fires
106: Assert.assertEquals(2, results.size());
107: Assert.assertEquals(31, ((Cheesery) results
108: .get(results.size() - 1)).getTotalAmount());
109:
110: // ---------------- 4th scenario
111: wm.retract(cheeseHandles[3]);
112: wm.fireAllRules();
113:
114: // should not have fired as per constraint
115: Assert.assertEquals(2, results.size());
116:
117: }
118:
119: public void testAccumulate() throws Exception {
120:
121: // read in the source
122: final Reader reader = new InputStreamReader(getClass()
123: .getResourceAsStream("test_Accumulate.drl"));
124: final RuleBase ruleBase = loadRuleBase(reader);
125:
126: final WorkingMemory wm = ruleBase.newStatefulSession();
127: final List results = new ArrayList();
128:
129: wm.setGlobal("results", results);
130:
131: wm.insert(new Person("Bob", "stilton", 20));
132: wm.insert(new Person("Mark", "provolone"));
133: wm.insert(new Cheese("stilton", 10));
134: wm.insert(new Cheese("brie", 5));
135: wm.insert(new Cheese("provolone", 150));
136:
137: wm.fireAllRules();
138:
139: Assert.assertEquals(new Integer(165), results.get(0));
140: Assert.assertEquals(new Integer(10), results.get(1));
141: Assert.assertEquals(new Integer(150), results.get(2));
142: Assert.assertEquals(new Integer(10), results.get(3));
143: Assert.assertEquals(new Integer(210), results.get(4));
144: }
145:
146: public void testMVELAccumulate() throws Exception {
147:
148: // read in the source
149: final Reader reader = new InputStreamReader(getClass()
150: .getResourceAsStream("test_AccumulateMVEL.drl"));
151: final RuleBase ruleBase = loadRuleBase(reader);
152:
153: final WorkingMemory wm = ruleBase.newStatefulSession();
154: final List results = new ArrayList();
155:
156: wm.setGlobal("results", results);
157:
158: wm.insert(new Person("Bob", "stilton", 20));
159: wm.insert(new Person("Mark", "provolone"));
160: wm.insert(new Cheese("stilton", 10));
161: wm.insert(new Cheese("brie", 5));
162: wm.insert(new Cheese("provolone", 150));
163:
164: wm.fireAllRules();
165:
166: Assert.assertEquals(new Integer(165), results.get(0));
167: Assert.assertEquals(new Integer(10), results.get(1));
168: Assert.assertEquals(new Integer(150), results.get(2));
169: Assert.assertEquals(new Integer(10), results.get(3));
170: Assert.assertEquals(new Integer(210), results.get(4));
171: }
172:
173: public void testAccumulateModifyMVEL() throws Exception {
174: // read in the source
175: final Reader reader = new InputStreamReader(getClass()
176: .getResourceAsStream("test_AccumulateModifyMVEL.drl"));
177: final RuleBase ruleBase = loadRuleBase(reader);
178:
179: final WorkingMemory wm = ruleBase.newStatefulSession();
180: final List results = new ArrayList();
181:
182: wm.setGlobal("results", results);
183:
184: final Cheese[] cheese = new Cheese[] {
185: new Cheese("stilton", 10), new Cheese("stilton", 2),
186: new Cheese("stilton", 5), new Cheese("brie", 15),
187: new Cheese("brie", 16), new Cheese("provolone", 8) };
188: final Person bob = new Person("Bob", "stilton");
189:
190: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
191: for (int i = 0; i < cheese.length; i++) {
192: cheeseHandles[i] = wm.insert(cheese[i]);
193: }
194: final FactHandle bobHandle = wm.insert(bob);
195:
196: // ---------------- 1st scenario
197: wm.fireAllRules();
198: // no fire, as per rule constraints
199: Assert.assertEquals(0, results.size());
200:
201: // ---------------- 2nd scenario
202: final int index = 1;
203: cheese[index].setPrice(9);
204: wm.update(cheeseHandles[index], cheese[index]);
205: wm.fireAllRules();
206:
207: // 1 fire
208: Assert.assertEquals(1, results.size());
209: Assert.assertEquals(24, ((Cheesery) results
210: .get(results.size() - 1)).getTotalAmount());
211:
212: // ---------------- 3rd scenario
213: bob.setLikes("brie");
214: wm.update(bobHandle, bob);
215: wm.fireAllRules();
216:
217: // 2 fires
218: Assert.assertEquals(2, results.size());
219: Assert.assertEquals(31, ((Cheesery) results
220: .get(results.size() - 1)).getTotalAmount());
221:
222: // ---------------- 4th scenario
223: wm.retract(cheeseHandles[3]);
224: wm.fireAllRules();
225:
226: // should not have fired as per constraint
227: Assert.assertEquals(2, results.size());
228:
229: }
230:
231: public void testAccumulateReverseModify() throws Exception {
232: // read in the source
233: final Reader reader = new InputStreamReader(
234: getClass().getResourceAsStream(
235: "test_AccumulateReverseModify.drl"));
236: final RuleBase ruleBase = loadRuleBase(reader);
237:
238: final WorkingMemory wm = ruleBase.newStatefulSession();
239: final List results = new ArrayList();
240:
241: wm.setGlobal("results", results);
242:
243: final Cheese[] cheese = new Cheese[] {
244: new Cheese("stilton", 10), new Cheese("stilton", 2),
245: new Cheese("stilton", 5), new Cheese("brie", 15),
246: new Cheese("brie", 16), new Cheese("provolone", 8) };
247: final Person bob = new Person("Bob", "stilton");
248:
249: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
250: for (int i = 0; i < cheese.length; i++) {
251: cheeseHandles[i] = wm.insert(cheese[i]);
252: }
253: final FactHandle bobHandle = wm.insert(bob);
254:
255: // ---------------- 1st scenario
256: wm.fireAllRules();
257: // no fire, as per rule constraints
258: Assert.assertEquals(0, results.size());
259:
260: // ---------------- 2nd scenario
261: final int index = 1;
262: cheese[index].setPrice(9);
263: wm.update(cheeseHandles[index], cheese[index]);
264: wm.fireAllRules();
265:
266: // 1 fire
267: Assert.assertEquals(1, results.size());
268: Assert.assertEquals(24, ((Cheesery) results
269: .get(results.size() - 1)).getTotalAmount());
270:
271: // ---------------- 3rd scenario
272: bob.setLikes("brie");
273: wm.update(bobHandle, bob);
274: wm.fireAllRules();
275:
276: // 2 fires
277: Assert.assertEquals(2, results.size());
278: Assert.assertEquals(31, ((Cheesery) results
279: .get(results.size() - 1)).getTotalAmount());
280:
281: // ---------------- 4th scenario
282: wm.retract(cheeseHandles[3]);
283: wm.fireAllRules();
284:
285: // should not have fired as per constraint
286: Assert.assertEquals(2, results.size());
287:
288: }
289:
290: public void testAccumulateReverseModifyMVEL() throws Exception {
291: // read in the source
292: final Reader reader = new InputStreamReader(getClass()
293: .getResourceAsStream(
294: "test_AccumulateReverseModifyMVEL.drl"));
295: final RuleBase ruleBase = loadRuleBase(reader);
296:
297: final WorkingMemory wm = ruleBase.newStatefulSession();
298: final List results = new ArrayList();
299:
300: wm.setGlobal("results", results);
301:
302: final Cheese[] cheese = new Cheese[] {
303: new Cheese("stilton", 10), new Cheese("stilton", 2),
304: new Cheese("stilton", 5), new Cheese("brie", 15),
305: new Cheese("brie", 16), new Cheese("provolone", 8) };
306: final Person bob = new Person("Bob", "stilton");
307:
308: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
309: for (int i = 0; i < cheese.length; i++) {
310: cheeseHandles[i] = wm.insert(cheese[i]);
311: }
312: final FactHandle bobHandle = wm.insert(bob);
313:
314: // ---------------- 1st scenario
315: wm.fireAllRules();
316: // no fire, as per rule constraints
317: Assert.assertEquals(0, results.size());
318:
319: // ---------------- 2nd scenario
320: final int index = 1;
321: cheese[index].setPrice(9);
322: wm.update(cheeseHandles[index], cheese[index]);
323: wm.fireAllRules();
324:
325: // 1 fire
326: Assert.assertEquals(1, results.size());
327: Assert.assertEquals(24, ((Cheesery) results
328: .get(results.size() - 1)).getTotalAmount());
329:
330: // ---------------- 3rd scenario
331: bob.setLikes("brie");
332: wm.update(bobHandle, bob);
333: wm.fireAllRules();
334:
335: // 2 fires
336: Assert.assertEquals(2, results.size());
337: Assert.assertEquals(31, ((Cheesery) results
338: .get(results.size() - 1)).getTotalAmount());
339:
340: // ---------------- 4th scenario
341: wm.retract(cheeseHandles[3]);
342: wm.fireAllRules();
343:
344: // should not have fired as per constraint
345: Assert.assertEquals(2, results.size());
346:
347: }
348:
349: public void testAccumulateWithFromChaining() throws Exception {
350: // read in the source
351: final Reader reader = new InputStreamReader(getClass()
352: .getResourceAsStream(
353: "test_AccumulateWithFromChaining.drl"));
354: final RuleBase ruleBase = loadRuleBase(reader);
355:
356: final WorkingMemory wm = ruleBase.newStatefulSession();
357: final List results = new ArrayList();
358:
359: wm.setGlobal("results", results);
360:
361: final Cheese[] cheese = new Cheese[] {
362: new Cheese("stilton", 8), new Cheese("stilton", 10),
363: new Cheese("stilton", 9), new Cheese("brie", 4),
364: new Cheese("brie", 1), new Cheese("provolone", 8) };
365:
366: Cheesery cheesery = new Cheesery();
367:
368: for (int i = 0; i < cheese.length; i++) {
369: cheesery.addCheese(cheese[i]);
370: }
371:
372: FactHandle cheeseryHandle = wm.insert(cheesery);
373:
374: final Person bob = new Person("Bob", "stilton");
375:
376: final FactHandle bobHandle = wm.insert(bob);
377:
378: // ---------------- 1st scenario
379: wm.fireAllRules();
380: // one fire, as per rule constraints
381: Assert.assertEquals(1, results.size());
382: Assert.assertEquals(3, ((List) results.get(results.size() - 1))
383: .size());
384:
385: // ---------------- 2nd scenario
386: final int index = 1;
387: cheese[index].setType("brie");
388: wm.update(cheeseryHandle, cheesery);
389: wm.fireAllRules();
390:
391: // no fire
392: Assert.assertEquals(1, results.size());
393:
394: // ---------------- 3rd scenario
395: bob.setLikes("brie");
396: wm.update(bobHandle, bob);
397: wm.fireAllRules();
398:
399: // 2 fires
400: Assert.assertEquals(2, results.size());
401: Assert.assertEquals(3, ((List) results.get(results.size() - 1))
402: .size());
403:
404: // ---------------- 4th scenario
405: cheesery.getCheeses().remove(cheese[3]);
406: wm.update(cheeseryHandle, cheesery);
407: wm.fireAllRules();
408:
409: // should not have fired as per constraint
410: Assert.assertEquals(2, results.size());
411:
412: }
413:
414: public void testMVELAccumulate2WM() throws Exception {
415:
416: // read in the source
417: final Reader reader = new InputStreamReader(getClass()
418: .getResourceAsStream("test_AccumulateMVEL.drl"));
419: final RuleBase ruleBase = loadRuleBase(reader);
420:
421: final WorkingMemory wm1 = ruleBase.newStatefulSession();
422: final List results1 = new ArrayList();
423:
424: wm1.setGlobal("results", results1);
425:
426: final WorkingMemory wm2 = ruleBase.newStatefulSession();
427: final List results2 = new ArrayList();
428:
429: wm2.setGlobal("results", results2);
430:
431: wm1.insert(new Person("Bob", "stilton", 20));
432: wm1.insert(new Person("Mark", "provolone"));
433:
434: wm2.insert(new Person("Bob", "stilton", 20));
435: wm2.insert(new Person("Mark", "provolone"));
436:
437: wm1.insert(new Cheese("stilton", 10));
438: wm1.insert(new Cheese("brie", 5));
439: wm2.insert(new Cheese("stilton", 10));
440: wm1.insert(new Cheese("provolone", 150));
441: wm2.insert(new Cheese("brie", 5));
442: wm2.insert(new Cheese("provolone", 150));
443: wm1.fireAllRules();
444:
445: wm2.fireAllRules();
446:
447: Assert.assertEquals(new Integer(165), results1.get(0));
448: Assert.assertEquals(new Integer(10), results1.get(1));
449: Assert.assertEquals(new Integer(150), results1.get(2));
450: Assert.assertEquals(new Integer(10), results1.get(3));
451: Assert.assertEquals(new Integer(210), results1.get(4));
452:
453: Assert.assertEquals(new Integer(165), results2.get(0));
454: Assert.assertEquals(new Integer(10), results2.get(1));
455: Assert.assertEquals(new Integer(150), results2.get(2));
456: Assert.assertEquals(new Integer(10), results2.get(3));
457: Assert.assertEquals(new Integer(210), results2.get(4));
458: }
459:
460: public void testAccumulateInnerClass() throws Exception {
461:
462: // read in the source
463: final Reader reader = new InputStreamReader(getClass()
464: .getResourceAsStream("test_AccumulateInnerClass.drl"));
465: final RuleBase ruleBase = loadRuleBase(reader);
466:
467: final WorkingMemory wm = ruleBase.newStatefulSession();
468: final List results = new ArrayList();
469:
470: wm.setGlobal("results", results);
471:
472: wm.insert(new OuterClass.InnerClass(10));
473: wm.insert(new OuterClass.InnerClass(5));
474:
475: wm.fireAllRules();
476:
477: Assert.assertEquals(new Integer(15), results.get(0));
478: }
479:
480: public void testAccumulateReturningNull() throws Exception {
481:
482: // read in the source
483: final Reader reader = new InputStreamReader(
484: getClass().getResourceAsStream(
485: "test_AccumulateReturningNull.drl"));
486: final RuleBase ruleBase = loadRuleBase(reader);
487:
488: final WorkingMemory wm = ruleBase.newStatefulSession();
489: final List results = new ArrayList();
490:
491: wm.setGlobal("results", results);
492:
493: try {
494: wm.insert(new Cheese("stilton", 10));
495:
496: fail("Should have raised an exception because accumulate is returning null");
497: } catch (RuntimeDroolsException rde) {
498: // success, working fine
499: } catch (Exception e) {
500: e.printStackTrace();
501: fail("Should have raised a DroolsRuntimeException instead of "
502: + e);
503: }
504:
505: }
506:
507: public void testAccumulateReturningNullMVEL() throws Exception {
508:
509: // read in the source
510: final Reader reader = new InputStreamReader(getClass()
511: .getResourceAsStream(
512: "test_AccumulateReturningNullMVEL.drl"));
513: final RuleBase ruleBase = loadRuleBase(reader);
514:
515: final WorkingMemory wm = ruleBase.newStatefulSession();
516: final List results = new ArrayList();
517:
518: wm.setGlobal("results", results);
519:
520: try {
521: wm.insert(new Cheese("stilton", 10));
522:
523: fail("Should have raised an exception because accumulate is returning null");
524: } catch (RuntimeDroolsException rde) {
525: // success, working fine
526: } catch (Exception e) {
527: e.printStackTrace();
528: fail("Should have raised a DroolsRuntimeException instead of "
529: + e);
530: }
531:
532: }
533:
534: public void testAccumulateSumJava() throws Exception {
535: execTestAccumulateSum("test_AccumulateSum.drl");
536: }
537:
538: public void testAccumulateSumMVEL() throws Exception {
539: execTestAccumulateSum("test_AccumulateSumMVEL.drl");
540: }
541:
542: public void testAccumulateCountJava() throws Exception {
543: execTestAccumulateCount("test_AccumulateCount.drl");
544: }
545:
546: public void testAccumulateCountMVEL() throws Exception {
547: execTestAccumulateCount("test_AccumulateCountMVEL.drl");
548: }
549:
550: public void testAccumulateAverageJava() throws Exception {
551: execTestAccumulateAverage("test_AccumulateAverage.drl");
552: }
553:
554: public void testAccumulateAverageMVEL() throws Exception {
555: execTestAccumulateAverage("test_AccumulateAverageMVEL.drl");
556: }
557:
558: public void testAccumulateMinJava() throws Exception {
559: execTestAccumulateMin("test_AccumulateMin.drl");
560: }
561:
562: public void testAccumulateMinMVEL() throws Exception {
563: execTestAccumulateMin("test_AccumulateMinMVEL.drl");
564: }
565:
566: public void testAccumulateMaxJava() throws Exception {
567: execTestAccumulateMax("test_AccumulateMax.drl");
568: }
569:
570: public void testAccumulateMaxMVEL() throws Exception {
571: execTestAccumulateMax("test_AccumulateMaxMVEL.drl");
572: }
573:
574: public void execTestAccumulateSum(String fileName) throws Exception {
575: // read in the source
576: final Reader reader = new InputStreamReader(getClass()
577: .getResourceAsStream(fileName));
578: final RuleBase ruleBase = loadRuleBase(reader);
579:
580: final WorkingMemory wm = ruleBase.newStatefulSession();
581: final List results = new ArrayList();
582:
583: wm.setGlobal("results", results);
584:
585: final Cheese[] cheese = new Cheese[] {
586: new Cheese("stilton", 8), new Cheese("stilton", 10),
587: new Cheese("stilton", 9), new Cheese("brie", 11),
588: new Cheese("brie", 4), new Cheese("provolone", 8) };
589: final Person bob = new Person("Bob", "stilton");
590:
591: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
592: for (int i = 0; i < cheese.length; i++) {
593: cheeseHandles[i] = wm.insert(cheese[i]);
594: }
595: final FactHandle bobHandle = wm.insert(bob);
596:
597: // ---------------- 1st scenario
598: wm.fireAllRules();
599: Assert.assertEquals(1, results.size());
600: Assert.assertEquals(27, ((Number) results
601: .get(results.size() - 1)).intValue());
602:
603: // ---------------- 2nd scenario
604: final int index = 1;
605: cheese[index].setPrice(3);
606: wm.update(cheeseHandles[index], cheese[index]);
607: wm.fireAllRules();
608:
609: Assert.assertEquals(2, results.size());
610: Assert.assertEquals(20, ((Number) results
611: .get(results.size() - 1)).intValue());
612:
613: // ---------------- 3rd scenario
614: bob.setLikes("brie");
615: wm.update(bobHandle, bob);
616: wm.fireAllRules();
617:
618: Assert.assertEquals(3, results.size());
619: Assert.assertEquals(15, ((Number) results
620: .get(results.size() - 1)).intValue());
621:
622: // ---------------- 4th scenario
623: wm.retract(cheeseHandles[3]);
624: wm.fireAllRules();
625:
626: // should not have fired as per constraint
627: Assert.assertEquals(3, results.size());
628:
629: }
630:
631: public void execTestAccumulateCount(String fileName)
632: throws Exception {
633: // read in the source
634: final Reader reader = new InputStreamReader(getClass()
635: .getResourceAsStream(fileName));
636: final RuleBase ruleBase = loadRuleBase(reader);
637:
638: final WorkingMemory wm = ruleBase.newStatefulSession();
639: final List results = new ArrayList();
640:
641: wm.setGlobal("results", results);
642:
643: final Cheese[] cheese = new Cheese[] {
644: new Cheese("stilton", 8), new Cheese("stilton", 10),
645: new Cheese("stilton", 9), new Cheese("brie", 4),
646: new Cheese("brie", 1), new Cheese("provolone", 8) };
647: final Person bob = new Person("Bob", "stilton");
648:
649: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
650: for (int i = 0; i < cheese.length; i++) {
651: cheeseHandles[i] = wm.insert(cheese[i]);
652: }
653: final FactHandle bobHandle = wm.insert(bob);
654:
655: // ---------------- 1st scenario
656: wm.fireAllRules();
657: // no fire, as per rule constraints
658: Assert.assertEquals(1, results.size());
659: Assert.assertEquals(3, ((Number) results
660: .get(results.size() - 1)).intValue());
661:
662: // ---------------- 2nd scenario
663: final int index = 1;
664: cheese[index].setPrice(3);
665: wm.update(cheeseHandles[index], cheese[index]);
666: wm.fireAllRules();
667:
668: // 1 fire
669: Assert.assertEquals(2, results.size());
670: Assert.assertEquals(3, ((Number) results
671: .get(results.size() - 1)).intValue());
672:
673: // ---------------- 3rd scenario
674: bob.setLikes("brie");
675: wm.update(bobHandle, bob);
676: wm.fireAllRules();
677:
678: // 2 fires
679: Assert.assertEquals(3, results.size());
680: Assert.assertEquals(2, ((Number) results
681: .get(results.size() - 1)).intValue());
682:
683: // ---------------- 4th scenario
684: wm.retract(cheeseHandles[3]);
685: wm.fireAllRules();
686:
687: // should not have fired as per constraint
688: Assert.assertEquals(3, results.size());
689:
690: }
691:
692: public void execTestAccumulateAverage(String fileName)
693: throws Exception {
694: // read in the source
695: final Reader reader = new InputStreamReader(getClass()
696: .getResourceAsStream(fileName));
697: final RuleBase ruleBase = loadRuleBase(reader);
698:
699: final WorkingMemory wm = ruleBase.newStatefulSession();
700: final List results = new ArrayList();
701:
702: wm.setGlobal("results", results);
703:
704: final Cheese[] cheese = new Cheese[] {
705: new Cheese("stilton", 10), new Cheese("stilton", 2),
706: new Cheese("stilton", 11), new Cheese("brie", 15),
707: new Cheese("brie", 17), new Cheese("provolone", 8) };
708: final Person bob = new Person("Bob", "stilton");
709:
710: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
711: for (int i = 0; i < cheese.length; i++) {
712: cheeseHandles[i] = wm.insert(cheese[i]);
713: }
714: final FactHandle bobHandle = wm.insert(bob);
715:
716: // ---------------- 1st scenario
717: wm.fireAllRules();
718: // no fire, as per rule constraints
719: Assert.assertEquals(0, results.size());
720:
721: // ---------------- 2nd scenario
722: final int index = 1;
723: cheese[index].setPrice(9);
724: wm.update(cheeseHandles[index], cheese[index]);
725: wm.fireAllRules();
726:
727: // 1 fire
728: Assert.assertEquals(1, results.size());
729: Assert.assertEquals(10, ((Number) results
730: .get(results.size() - 1)).intValue());
731:
732: // ---------------- 3rd scenario
733: bob.setLikes("brie");
734: wm.update(bobHandle, bob);
735: wm.fireAllRules();
736:
737: // 2 fires
738: Assert.assertEquals(2, results.size());
739: Assert.assertEquals(16, ((Number) results
740: .get(results.size() - 1)).intValue());
741:
742: // ---------------- 4th scenario
743: wm.retract(cheeseHandles[3]);
744: wm.retract(cheeseHandles[4]);
745: wm.fireAllRules();
746:
747: // should not have fired as per constraint
748: Assert.assertEquals(2, results.size());
749:
750: }
751:
752: public void execTestAccumulateMin(String fileName) throws Exception {
753: // read in the source
754: final Reader reader = new InputStreamReader(getClass()
755: .getResourceAsStream(fileName));
756: final RuleBase ruleBase = loadRuleBase(reader);
757:
758: final WorkingMemory wm = ruleBase.newStatefulSession();
759: final List results = new ArrayList();
760:
761: wm.setGlobal("results", results);
762:
763: final Cheese[] cheese = new Cheese[] {
764: new Cheese("stilton", 8), new Cheese("stilton", 10),
765: new Cheese("stilton", 9), new Cheese("brie", 4),
766: new Cheese("brie", 1), new Cheese("provolone", 8) };
767: final Person bob = new Person("Bob", "stilton");
768:
769: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
770: for (int i = 0; i < cheese.length; i++) {
771: cheeseHandles[i] = wm.insert(cheese[i]);
772: }
773: final FactHandle bobHandle = wm.insert(bob);
774:
775: // ---------------- 1st scenario
776: wm.fireAllRules();
777: // no fire, as per rule constraints
778: Assert.assertEquals(0, results.size());
779:
780: // ---------------- 2nd scenario
781: final int index = 1;
782: cheese[index].setPrice(3);
783: wm.update(cheeseHandles[index], cheese[index]);
784: wm.fireAllRules();
785:
786: // 1 fire
787: Assert.assertEquals(1, results.size());
788: Assert.assertEquals(3, ((Number) results
789: .get(results.size() - 1)).intValue());
790:
791: // ---------------- 3rd scenario
792: bob.setLikes("brie");
793: wm.update(bobHandle, bob);
794: wm.fireAllRules();
795:
796: // 2 fires
797: Assert.assertEquals(2, results.size());
798: Assert.assertEquals(1, ((Number) results
799: .get(results.size() - 1)).intValue());
800:
801: // ---------------- 4th scenario
802: wm.retract(cheeseHandles[3]);
803: wm.retract(cheeseHandles[4]);
804: wm.fireAllRules();
805:
806: // should not have fired as per constraint
807: Assert.assertEquals(2, results.size());
808:
809: }
810:
811: public void execTestAccumulateMax(String fileName) throws Exception {
812: // read in the source
813: final Reader reader = new InputStreamReader(getClass()
814: .getResourceAsStream(fileName));
815: final RuleBase ruleBase = loadRuleBase(reader);
816:
817: final WorkingMemory wm = ruleBase.newStatefulSession();
818: final List results = new ArrayList();
819:
820: wm.setGlobal("results", results);
821:
822: final Cheese[] cheese = new Cheese[] {
823: new Cheese("stilton", 4), new Cheese("stilton", 2),
824: new Cheese("stilton", 3), new Cheese("brie", 15),
825: new Cheese("brie", 17), new Cheese("provolone", 8) };
826: final Person bob = new Person("Bob", "stilton");
827:
828: final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
829: for (int i = 0; i < cheese.length; i++) {
830: cheeseHandles[i] = wm.insert(cheese[i]);
831: }
832: final FactHandle bobHandle = wm.insert(bob);
833:
834: // ---------------- 1st scenario
835: wm.fireAllRules();
836: // no fire, as per rule constraints
837: Assert.assertEquals(0, results.size());
838:
839: // ---------------- 2nd scenario
840: final int index = 1;
841: cheese[index].setPrice(9);
842: wm.update(cheeseHandles[index], cheese[index]);
843: wm.fireAllRules();
844:
845: // 1 fire
846: Assert.assertEquals(1, results.size());
847: Assert.assertEquals(9, ((Number) results
848: .get(results.size() - 1)).intValue());
849:
850: // ---------------- 3rd scenario
851: bob.setLikes("brie");
852: wm.update(bobHandle, bob);
853: wm.fireAllRules();
854:
855: // 2 fires
856: Assert.assertEquals(2, results.size());
857: Assert.assertEquals(17, ((Number) results
858: .get(results.size() - 1)).intValue());
859:
860: // ---------------- 4th scenario
861: wm.retract(cheeseHandles[3]);
862: wm.retract(cheeseHandles[4]);
863: wm.fireAllRules();
864:
865: // should not have fired as per constraint
866: Assert.assertEquals(2, results.size());
867:
868: }
869:
870: }
|