0001: package org.drools.integrationtests;
0002:
0003: /*
0004: * Copyright 2005 JBoss Inc
0005: *
0006: * Licensed under the Apache License, Version 2.0 (the "License");
0007: * you may not use this file except in compliance with the License.
0008: * You may obtain a copy of the License at
0009: *
0010: * http://www.apache.org/licenses/LICENSE-2.0
0011: *
0012: * Unless required by applicable law or agreed to in writing, software
0013: * distributed under the License is distributed on an "AS IS" BASIS,
0014: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0015: * See the License for the specific language governing permissions and
0016: * limitations under the License.
0017: */
0018:
0019: import java.io.ByteArrayInputStream;
0020: import java.io.ByteArrayOutputStream;
0021: import java.io.IOException;
0022: import java.io.InputStreamReader;
0023: import java.io.ObjectInput;
0024: import java.io.ObjectInputStream;
0025: import java.io.ObjectOutput;
0026: import java.io.ObjectOutputStream;
0027: import java.io.Reader;
0028: import java.io.StringReader;
0029: import java.math.BigDecimal;
0030: import java.util.ArrayList;
0031: import java.util.HashMap;
0032: import java.util.Iterator;
0033: import java.util.List;
0034: import java.util.Map;
0035:
0036: import junit.framework.Assert;
0037: import junit.framework.TestCase;
0038:
0039: import org.acme.insurance.Driver;
0040: import org.acme.insurance.Policy;
0041: import org.drools.Address;
0042: import org.drools.Cell;
0043: import org.drools.Cheese;
0044: import org.drools.Cheesery;
0045: import org.drools.Child;
0046: import org.drools.FactHandle;
0047: import org.drools.FirstClass;
0048: import org.drools.FromTestClass;
0049: import org.drools.Guess;
0050: import org.drools.IndexedNumber;
0051: import org.drools.InsertedObject;
0052: import org.drools.Order;
0053: import org.drools.OrderItem;
0054: import org.drools.Person;
0055: import org.drools.PersonInterface;
0056: import org.drools.PersonWithEquals;
0057: import org.drools.Primitives;
0058: import org.drools.QueryResults;
0059: import org.drools.RandomNumber;
0060: import org.drools.RuleBase;
0061: import org.drools.RuleBaseConfiguration;
0062: import org.drools.RuleBaseFactory;
0063: import org.drools.SecondClass;
0064: import org.drools.Sensor;
0065: import org.drools.SpecialString;
0066: import org.drools.State;
0067: import org.drools.StatefulSession;
0068: import org.drools.StatelessSession;
0069: import org.drools.TestParam;
0070: import org.drools.WorkingMemory;
0071: import org.drools.Cheesery.Maturity;
0072: import org.drools.base.ClassObjectFilter;
0073: import org.drools.common.AbstractWorkingMemory;
0074: import org.drools.compiler.DrlParser;
0075: import org.drools.compiler.DroolsError;
0076: import org.drools.compiler.DroolsParserException;
0077: import org.drools.compiler.PackageBuilder;
0078: import org.drools.compiler.PackageBuilderConfiguration;
0079: import org.drools.compiler.ParserError;
0080: import org.drools.compiler.RuleError;
0081: import org.drools.compiler.PackageBuilder.PackageMergeException;
0082: import org.drools.event.ActivationCancelledEvent;
0083: import org.drools.event.ActivationCreatedEvent;
0084: import org.drools.event.AfterActivationFiredEvent;
0085: import org.drools.event.AgendaEventListener;
0086: import org.drools.event.AgendaGroupPoppedEvent;
0087: import org.drools.event.AgendaGroupPushedEvent;
0088: import org.drools.event.BeforeActivationFiredEvent;
0089: import org.drools.event.DefaultWorkingMemoryEventListener;
0090: import org.drools.event.ObjectInsertedEvent;
0091: import org.drools.event.ObjectRetractedEvent;
0092: import org.drools.event.ObjectUpdatedEvent;
0093: import org.drools.event.WorkingMemoryEventListener;
0094: import org.drools.facttemplates.Fact;
0095: import org.drools.facttemplates.FactTemplate;
0096: import org.drools.integrationtests.helloworld.Message;
0097: import org.drools.lang.DrlDumper;
0098: import org.drools.lang.descr.AttributeDescr;
0099: import org.drools.lang.descr.PackageDescr;
0100: import org.drools.lang.descr.RuleDescr;
0101: import org.drools.rule.InvalidRulePackage;
0102: import org.drools.rule.Package;
0103: import org.drools.rule.Rule;
0104: import org.drools.rule.builder.dialect.java.JavaDialectConfiguration;
0105: import org.drools.spi.Activation;
0106: import org.drools.spi.ConsequenceExceptionHandler;
0107: import org.drools.xml.XmlDumper;
0108:
0109: /** Run all the tests with the ReteOO engine implementation */
0110: public class MiscTest extends TestCase {
0111:
0112: protected RuleBase getRuleBase() throws Exception {
0113:
0114: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, null);
0115: }
0116:
0117: protected RuleBase getRuleBase(final RuleBaseConfiguration config)
0118: throws Exception {
0119:
0120: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, config);
0121: }
0122:
0123: public void testGlobals() throws Exception {
0124:
0125: final PackageBuilder builder = new PackageBuilder();
0126: builder.addPackageFromDrl(new InputStreamReader(getClass()
0127: .getResourceAsStream("globals_rule_test.drl")));
0128: final Package pkg = builder.getPackage();
0129:
0130: final RuleBase ruleBase = getRuleBase();
0131: ruleBase.addPackage(pkg);
0132: final WorkingMemory workingMemory = ruleBase
0133: .newStatefulSession();
0134:
0135: final List list = new ArrayList();
0136: workingMemory.setGlobal("list", list);
0137:
0138: workingMemory.setGlobal("string", "stilton");
0139:
0140: final Cheese stilton = new Cheese("stilton", 5);
0141: workingMemory.insert(stilton);
0142:
0143: workingMemory.fireAllRules();
0144:
0145: assertEquals(new Integer(5), list.get(0));
0146: }
0147:
0148: public void testFieldBiningsAndEvalSharing() throws Exception {
0149: final String drl = "test_FieldBindingsAndEvalSharing.drl";
0150: evalSharingTest(drl);
0151: }
0152:
0153: public void testFieldBiningsAndPredicateSharing() throws Exception {
0154: final String drl = "test_FieldBindingsAndPredicateSharing.drl";
0155: evalSharingTest(drl);
0156: }
0157:
0158: private void evalSharingTest(final String drl)
0159: throws DroolsParserException, IOException, Exception {
0160: final PackageBuilder builder = new PackageBuilder();
0161: builder.addPackageFromDrl(new InputStreamReader(getClass()
0162: .getResourceAsStream(drl)));
0163: final Package pkg = builder.getPackage();
0164:
0165: final RuleBase ruleBase = getRuleBase();
0166: ruleBase.addPackage(pkg);
0167: final WorkingMemory wm = ruleBase.newStatefulSession();
0168:
0169: final List list = new ArrayList();
0170: wm.setGlobal("list", list);
0171:
0172: final TestParam tp1 = new TestParam();
0173: tp1.setValue2("boo");
0174: wm.insert(tp1);
0175:
0176: wm.fireAllRules();
0177:
0178: assertEquals(1, list.size());
0179: }
0180:
0181: public void testFactBindings() throws Exception {
0182: final PackageBuilder builder = new PackageBuilder();
0183: builder.addPackageFromDrl(new InputStreamReader(getClass()
0184: .getResourceAsStream("test_FactBindings.drl")));
0185: final Package pkg = builder.getPackage();
0186:
0187: // add the package to a rulebase
0188: final RuleBase ruleBase = getRuleBase();
0189: ruleBase.addPackage(pkg);
0190:
0191: final WorkingMemory workingMemory = ruleBase
0192: .newStatefulSession();
0193:
0194: final List events = new ArrayList();
0195: final WorkingMemoryEventListener listener = new DefaultWorkingMemoryEventListener() {
0196: public void objectUpdated(ObjectUpdatedEvent event) {
0197: events.add(event);
0198: }
0199: };
0200:
0201: workingMemory.addEventListener(listener);
0202:
0203: final Person bigCheese = new Person("big cheese");
0204: final Cheese cheddar = new Cheese("cheddar", 15);
0205: bigCheese.setCheese(cheddar);
0206:
0207: final FactHandle bigCheeseHandle = workingMemory
0208: .insert(bigCheese);
0209: final FactHandle cheddarHandle = workingMemory.insert(cheddar);
0210: workingMemory.fireAllRules();
0211:
0212: ObjectUpdatedEvent event = (ObjectUpdatedEvent) events.get(0);
0213: assertSame(cheddarHandle, event.getFactHandle());
0214: assertSame(cheddar, event.getOldObject());
0215: assertSame(cheddar, event.getObject());
0216:
0217: event = (ObjectUpdatedEvent) events.get(1);
0218: assertSame(bigCheeseHandle, event.getFactHandle());
0219: assertSame(bigCheese, event.getOldObject());
0220: assertSame(bigCheese, event.getObject());
0221: }
0222:
0223: public void testNullHandling() throws Exception {
0224: final PackageBuilder builder = new PackageBuilder();
0225: builder.addPackageFromDrl(new InputStreamReader(getClass()
0226: .getResourceAsStream("test_NullHandling.drl")));
0227: final Package pkg = builder.getPackage();
0228:
0229: // add the package to a rulebase
0230: final RuleBase ruleBase = getRuleBase();
0231: ruleBase.addPackage(pkg);
0232:
0233: final WorkingMemory workingMemory = ruleBase
0234: .newStatefulSession();
0235:
0236: final List list = new ArrayList();
0237: workingMemory.setGlobal("list", list);
0238: final Cheese nullCheese = new Cheese(null, 2);
0239: workingMemory.insert(nullCheese);
0240:
0241: final Person notNullPerson = new Person("shoes butt back");
0242: notNullPerson.setBigDecimal(new BigDecimal("42.42"));
0243:
0244: workingMemory.insert(notNullPerson);
0245:
0246: final Person nullPerson = new Person("whee");
0247: nullPerson.setBigDecimal(null);
0248:
0249: workingMemory.insert(nullPerson);
0250:
0251: workingMemory.fireAllRules();
0252: System.out.println(list.get(0));
0253: assertEquals(3, list.size());
0254:
0255: }
0256:
0257: public void testEmptyPattern() throws Exception {
0258: // pre build the package
0259: final PackageBuilder builder = new PackageBuilder();
0260: builder.addPackageFromDrl(new InputStreamReader(getClass()
0261: .getResourceAsStream("test_EmptyPattern.drl")));
0262: final Package pkg = builder.getPackage();
0263:
0264: // add the package to a rulebase
0265: final RuleBase ruleBase = getRuleBase();
0266: ruleBase.addPackage(pkg);
0267:
0268: final WorkingMemory workingMemory = ruleBase
0269: .newStatefulSession();
0270:
0271: final List list = new ArrayList();
0272: workingMemory.setGlobal("list", list);
0273:
0274: final Cheese stilton = new Cheese("stilton", 5);
0275: workingMemory.insert(stilton);
0276:
0277: workingMemory.fireAllRules();
0278:
0279: assertEquals(new Integer(5), list.get(0));
0280: }
0281:
0282: private RuleBase loadRuleBase(final Reader reader)
0283: throws IOException, DroolsParserException, Exception {
0284: final DrlParser parser = new DrlParser();
0285: final PackageDescr packageDescr = parser.parse(reader);
0286: if (parser.hasErrors()) {
0287: Assert
0288: .fail("Error messages in parser, need to sort this our (or else collect error messages)");
0289: }
0290: // pre build the package
0291: final PackageBuilder builder = new PackageBuilder();
0292: builder.addPackage(packageDescr);
0293: final Package pkg = builder.getPackage();
0294:
0295: // add the package to a rulebase
0296: final RuleBase ruleBase = getRuleBase();
0297: ruleBase.addPackage(pkg);
0298: // load up the rulebase
0299: return ruleBase;
0300: }
0301:
0302: public void testExplicitAnd() throws Exception {
0303: final Reader reader = new InputStreamReader(getClass()
0304: .getResourceAsStream("test_ExplicitAnd.drl"));
0305: final RuleBase ruleBase = loadRuleBase(reader);
0306:
0307: final WorkingMemory workingMemory = ruleBase
0308: .newStatefulSession();
0309: final List list = new ArrayList();
0310: workingMemory.setGlobal("list", list);
0311: workingMemory.insert(new Message("hola"));
0312:
0313: workingMemory.fireAllRules();
0314: assertEquals(0, list.size());
0315:
0316: workingMemory.insert(new Cheese("brie", 33));
0317:
0318: workingMemory.fireAllRules();
0319: assertEquals(1, list.size());
0320: }
0321:
0322: public void testHelloWorld() throws Exception {
0323:
0324: // read in the source
0325: final Reader reader = new InputStreamReader(getClass()
0326: .getResourceAsStream("HelloWorld.drl"));
0327: final RuleBase ruleBase = loadRuleBase(reader);
0328:
0329: final WorkingMemory workingMemory = ruleBase
0330: .newStatefulSession();
0331:
0332: final List list = new ArrayList();
0333: workingMemory.setGlobal("list", list);
0334:
0335: // go !
0336: final Message message = new Message("hola");
0337: message.addToList("hello");
0338: message.setNumber(42);
0339:
0340: workingMemory.insert(message);
0341: workingMemory.insert("boo");
0342: workingMemory.fireAllRules();
0343: assertTrue(message.isFired());
0344: assertEquals(message, list.get(0));
0345:
0346: }
0347:
0348: public void testLiteral() throws Exception {
0349: final PackageBuilder builder = new PackageBuilder();
0350: builder.addPackageFromDrl(new InputStreamReader(getClass()
0351: .getResourceAsStream("literal_rule_test.drl")));
0352: final Package pkg = builder.getPackage();
0353:
0354: final RuleBase ruleBase = getRuleBase();
0355: ruleBase.addPackage(pkg);
0356: final WorkingMemory workingMemory = ruleBase
0357: .newStatefulSession();
0358:
0359: final List list = new ArrayList();
0360: workingMemory.setGlobal("list", list);
0361:
0362: final Cheese stilton = new Cheese("stilton", 5);
0363: workingMemory.insert(stilton);
0364:
0365: workingMemory.fireAllRules();
0366:
0367: assertEquals("stilton", list.get(0));
0368: }
0369:
0370: public void testLiteralWithBoolean() throws Exception {
0371: final PackageBuilder builder = new PackageBuilder();
0372: builder.addPackageFromDrl(new InputStreamReader(getClass()
0373: .getResourceAsStream("literal_with_boolean.drl")));
0374: final Package pkg = builder.getPackage();
0375:
0376: final RuleBase ruleBase = getRuleBase();
0377: ruleBase.addPackage(pkg);
0378: final WorkingMemory workingMemory = ruleBase
0379: .newStatefulSession();
0380:
0381: final List list = new ArrayList();
0382: workingMemory.setGlobal("list", list);
0383:
0384: final PersonInterface bill = new Person("bill", null, 12);
0385: bill.setAlive(true);
0386: workingMemory.insert(bill);
0387: workingMemory.fireAllRules();
0388:
0389: assertEquals(bill, list.get(0));
0390: }
0391:
0392: public void testFactTemplate() throws Exception {
0393: final PackageBuilder builder = new PackageBuilder();
0394: builder.addPackageFromDrl(new InputStreamReader(getClass()
0395: .getResourceAsStream("test_FactTemplate.drl")));
0396: final Package pkg = builder.getPackage();
0397:
0398: final RuleBase ruleBase = getRuleBase();
0399: ruleBase.addPackage(pkg);
0400: final WorkingMemory workingMemory = ruleBase
0401: .newStatefulSession();
0402:
0403: final List list = new ArrayList();
0404: workingMemory.setGlobal("list", list);
0405:
0406: final FactTemplate cheese = pkg.getFactTemplate("Cheese");
0407: final Fact stilton = cheese.createFact(0);
0408: stilton.setFieldValue("name", "stilton");
0409: stilton.setFieldValue("price", new Integer(100));
0410: workingMemory.insert(stilton);
0411: workingMemory.fireAllRules();
0412:
0413: assertEquals(1, list.size());
0414: assertEquals(stilton, list.get(0));
0415: final Fact fact = (Fact) list.get(0);
0416: assertSame(stilton, fact);
0417: assertEquals(new Integer(200), fact.getFieldValue("price"));
0418:
0419: }
0420:
0421: public void testPropertyChangeSupport() throws Exception {
0422: final PackageBuilder builder = new PackageBuilder();
0423: builder.addPackageFromDrl(new InputStreamReader(getClass()
0424: .getResourceAsStream("test_PropertyChange.drl")));
0425: final Package pkg = builder.getPackage();
0426:
0427: final RuleBase ruleBase = getRuleBase();
0428: ruleBase.addPackage(pkg);
0429: final WorkingMemory workingMemory = ruleBase
0430: .newStatefulSession();
0431:
0432: final List list = new ArrayList();
0433: workingMemory.setGlobal("list", list);
0434:
0435: final State state = new State("initial");
0436: workingMemory.insert(state, true);
0437: workingMemory.fireAllRules();
0438:
0439: assertEquals(1, list.size());
0440:
0441: state.setFlag(true);
0442: assertEquals(1, list.size());
0443:
0444: workingMemory.fireAllRules();
0445: assertEquals(2, list.size());
0446:
0447: state.setState("finished");
0448: workingMemory.fireAllRules();
0449: assertEquals(3, list.size());
0450:
0451: }
0452:
0453: public void testBigDecimal() throws Exception {
0454:
0455: final PackageBuilder builder = new PackageBuilder();
0456: builder
0457: .addPackageFromDrl(new InputStreamReader(getClass()
0458: .getResourceAsStream(
0459: "big_decimal_and_comparable.drl")));
0460: final Package pkg = builder.getPackage();
0461:
0462: final RuleBase ruleBase = getRuleBase();
0463: ruleBase.addPackage(pkg);
0464: final WorkingMemory workingMemory = ruleBase
0465: .newStatefulSession();
0466:
0467: final List list = new ArrayList();
0468: workingMemory.setGlobal("list", list);
0469:
0470: final PersonInterface bill = new Person("bill", null, 12);
0471: bill.setBigDecimal(new BigDecimal("42"));
0472:
0473: final PersonInterface ben = new Person("ben", null, 13);
0474: ben.setBigDecimal(new BigDecimal("43"));
0475:
0476: workingMemory.insert(bill);
0477: workingMemory.insert(ben);
0478: workingMemory.fireAllRules();
0479:
0480: assertEquals(1, list.size());
0481: }
0482:
0483: public void testCell() throws Exception {
0484: final Cell cell1 = new Cell(9);
0485: final Cell cell = new Cell(0);
0486:
0487: final PackageBuilder builder = new PackageBuilder();
0488: builder.addPackageFromDrl(new InputStreamReader(getClass()
0489: .getResourceAsStream("evalmodify.drl")));
0490:
0491: final RuleBase ruleBase = getRuleBase();
0492: ruleBase.addPackage(builder.getPackage());
0493:
0494: final WorkingMemory memory = ruleBase.newStatefulSession();
0495: memory.insert(cell1);
0496: memory.insert(cell);
0497: memory.fireAllRules();
0498: assertEquals(9, cell.getValue());
0499: }
0500:
0501: public void testNesting() throws Exception {
0502: Person p = new Person();
0503: p.setName("Michael");
0504:
0505: Address add1 = new Address();
0506: add1.setStreet("High");
0507:
0508: Address add2 = new Address();
0509: add2.setStreet("Low");
0510:
0511: List l = new ArrayList();
0512: l.add(add1);
0513: l.add(add2);
0514:
0515: p.setAddresses(l);
0516:
0517: final PackageBuilder builder = new PackageBuilder();
0518: builder.addPackageFromDrl(new InputStreamReader(getClass()
0519: .getResourceAsStream("nested_fields.drl")));
0520:
0521: assertFalse(builder.getErrors().toString(), builder.hasErrors());
0522:
0523: DrlParser parser = new DrlParser();
0524: PackageDescr desc = parser.parse(new InputStreamReader(
0525: getClass().getResourceAsStream("nested_fields.drl")));
0526: List packageAttrs = desc.getAttributes();
0527: assertEquals(1, desc.getRules().size());
0528: assertEquals(1, packageAttrs.size());
0529:
0530: RuleDescr rule = (RuleDescr) desc.getRules().get(0);
0531: List ruleAttrs = rule.getAttributes();
0532: assertEquals(1, ruleAttrs.size());
0533:
0534: assertEquals("mvel", ((AttributeDescr) ruleAttrs.get(0))
0535: .getValue());
0536: assertEquals("dialect", ((AttributeDescr) ruleAttrs.get(0))
0537: .getName());
0538: final RuleBase ruleBase = getRuleBase();
0539: ruleBase.addPackage(builder.getPackage());
0540:
0541: final WorkingMemory memory = ruleBase.newStatefulSession();
0542:
0543: memory.insert(p);
0544: memory.fireAllRules();
0545:
0546: }
0547:
0548: public void testOr() throws Exception {
0549: final PackageBuilder builder = new PackageBuilder();
0550: builder.addPackageFromDrl(new InputStreamReader(getClass()
0551: .getResourceAsStream("or_test.drl")));
0552: final Package pkg = builder.getPackage();
0553:
0554: final RuleBase ruleBase = getRuleBase();
0555: ruleBase.addPackage(pkg);
0556: final WorkingMemory workingMemory = ruleBase
0557: .newStatefulSession();
0558: final List list = new ArrayList();
0559: workingMemory.setGlobal("list", list);
0560:
0561: final Cheese cheddar = new Cheese("cheddar", 5);
0562: final FactHandle h = workingMemory.insert(cheddar);
0563:
0564: workingMemory.fireAllRules();
0565:
0566: // just one added
0567: assertEquals("got cheese", list.get(0));
0568: assertEquals(1, list.size());
0569:
0570: workingMemory.retract(h);
0571: workingMemory.fireAllRules();
0572:
0573: // still just one
0574: assertEquals(1, list.size());
0575:
0576: workingMemory.insert(new Cheese("stilton", 5));
0577: workingMemory.fireAllRules();
0578:
0579: // now have one more
0580: assertEquals(2, list.size());
0581:
0582: }
0583:
0584: public void testQuery() throws Exception {
0585: final PackageBuilder builder = new PackageBuilder();
0586: builder.addPackageFromDrl(new InputStreamReader(getClass()
0587: .getResourceAsStream("simple_query_test.drl")));
0588: final Package pkg = builder.getPackage();
0589:
0590: final RuleBase ruleBase = getRuleBase();
0591: ruleBase.addPackage(pkg);
0592: final WorkingMemory workingMemory = ruleBase
0593: .newStatefulSession();
0594:
0595: final Cheese stilton = new Cheese("stinky", 5);
0596: workingMemory.insert(stilton);
0597: final QueryResults results = workingMemory
0598: .getQueryResults("simple query");
0599: assertEquals(1, results.size());
0600: }
0601:
0602: public void testEval() throws Exception {
0603: final PackageBuilder builder = new PackageBuilder();
0604: builder.addPackageFromDrl(new InputStreamReader(getClass()
0605: .getResourceAsStream("eval_rule_test.drl")));
0606: final Package pkg = builder.getPackage();
0607:
0608: final RuleBase ruleBase = getRuleBase();
0609: ruleBase.addPackage(pkg);
0610: final WorkingMemory workingMemory = ruleBase
0611: .newStatefulSession();
0612:
0613: workingMemory.setGlobal("five", new Integer(5));
0614:
0615: final List list = new ArrayList();
0616: workingMemory.setGlobal("list", list);
0617:
0618: final Cheese stilton = new Cheese("stilton", 5);
0619: workingMemory.insert(stilton);
0620: workingMemory.fireAllRules();
0621:
0622: assertEquals(stilton, list.get(0));
0623: }
0624:
0625: public void testJaninoEval() throws Exception {
0626: final PackageBuilderConfiguration config = new PackageBuilderConfiguration();
0627: JavaDialectConfiguration javaConf = (JavaDialectConfiguration) config
0628: .getDialectConfiguration("java");
0629: javaConf.setCompiler(JavaDialectConfiguration.JANINO);
0630:
0631: final PackageBuilder builder = new PackageBuilder(config);
0632: builder.addPackageFromDrl(new InputStreamReader(getClass()
0633: .getResourceAsStream("eval_rule_test.drl")));
0634: final Package pkg = builder.getPackage();
0635:
0636: final RuleBase ruleBase = getRuleBase();
0637: ruleBase.addPackage(pkg);
0638: final WorkingMemory workingMemory = ruleBase
0639: .newStatefulSession();
0640:
0641: workingMemory.setGlobal("five", new Integer(5));
0642:
0643: final List list = new ArrayList();
0644: workingMemory.setGlobal("list", list);
0645:
0646: final Cheese stilton = new Cheese("stilton", 5);
0647: workingMemory.insert(stilton);
0648: workingMemory.fireAllRules();
0649:
0650: assertEquals(stilton, list.get(0));
0651: }
0652:
0653: public void testEvalMore() throws Exception {
0654: final PackageBuilder builder = new PackageBuilder();
0655: builder.addPackageFromDrl(new InputStreamReader(getClass()
0656: .getResourceAsStream("eval_rule_test_more.drl")));
0657: final Package pkg = builder.getPackage();
0658:
0659: final RuleBase ruleBase = getRuleBase();
0660: ruleBase.addPackage(pkg);
0661: final WorkingMemory workingMemory = ruleBase
0662: .newStatefulSession();
0663:
0664: final List list = new ArrayList();
0665: workingMemory.setGlobal("list", list);
0666:
0667: final Person foo = new Person("foo");
0668: workingMemory.insert(foo);
0669: workingMemory.fireAllRules();
0670:
0671: assertEquals(foo, list.get(0));
0672: }
0673:
0674: public void testReturnValue() throws Exception {
0675: final PackageBuilder builder = new PackageBuilder();
0676: builder.addPackageFromDrl(new InputStreamReader(getClass()
0677: .getResourceAsStream("returnvalue_rule_test.drl")));
0678: final Package pkg = builder.getPackage();
0679:
0680: final RuleBase ruleBase = getRuleBase();
0681: ruleBase.addPackage(pkg);
0682: final WorkingMemory workingMemory = ruleBase
0683: .newStatefulSession();
0684:
0685: workingMemory.setGlobal("two", new Integer(2));
0686:
0687: final List list = new ArrayList();
0688: workingMemory.setGlobal("list", list);
0689:
0690: final PersonInterface peter = new Person("peter", null, 12);
0691: workingMemory.insert(peter);
0692: final PersonInterface jane = new Person("jane", null, 10);
0693: workingMemory.insert(jane);
0694:
0695: workingMemory.fireAllRules();
0696:
0697: assertEquals(jane, list.get(0));
0698: assertEquals(peter, list.get(1));
0699: }
0700:
0701: public void testPredicate() throws Exception {
0702: final PackageBuilder builder = new PackageBuilder();
0703: builder.addPackageFromDrl(new InputStreamReader(getClass()
0704: .getResourceAsStream("predicate_rule_test.drl")));
0705: final Package pkg = builder.getPackage();
0706:
0707: final RuleBase ruleBase = getRuleBase();
0708: ruleBase.addPackage(pkg);
0709: final WorkingMemory workingMemory = ruleBase
0710: .newStatefulSession();
0711:
0712: workingMemory.setGlobal("two", new Integer(2));
0713:
0714: final List list = new ArrayList();
0715: workingMemory.setGlobal("list", list);
0716:
0717: final PersonInterface peter = new Person("peter", null, 12);
0718: workingMemory.insert(peter);
0719: final PersonInterface jane = new Person("jane", null, 10);
0720: workingMemory.insert(jane);
0721:
0722: workingMemory.fireAllRules();
0723:
0724: assertEquals(jane, list.get(0));
0725: assertEquals(peter, list.get(1));
0726: }
0727:
0728: public void testNullBehaviour() throws Exception {
0729: final PackageBuilder builder = new PackageBuilder();
0730: builder.addPackageFromDrl(new InputStreamReader(getClass()
0731: .getResourceAsStream("null_behaviour.drl")));
0732: final Package pkg = builder.getPackage();
0733:
0734: final RuleBase ruleBase = getRuleBase();
0735: ruleBase.addPackage(pkg);
0736: final WorkingMemory workingMemory = ruleBase
0737: .newStatefulSession();
0738:
0739: final PersonInterface p1 = new Person("michael", "food", 40);
0740: final PersonInterface p2 = new Person(null, "drink", 30);
0741: workingMemory.insert(p1);
0742: workingMemory.insert(p2);
0743:
0744: workingMemory.fireAllRules();
0745:
0746: }
0747:
0748: public void testNullConstraint() throws Exception {
0749: final PackageBuilder builder = new PackageBuilder();
0750: builder.addPackageFromDrl(new InputStreamReader(getClass()
0751: .getResourceAsStream("null_constraint.drl")));
0752: final Package pkg = builder.getPackage();
0753:
0754: final RuleBase ruleBase = getRuleBase();
0755: ruleBase.addPackage(pkg);
0756: final WorkingMemory workingMemory = ruleBase
0757: .newStatefulSession();
0758: final List foo = new ArrayList();
0759: workingMemory.setGlobal("messages", foo);
0760:
0761: final PersonInterface p1 = new Person(null, "food", 40);
0762: final Primitives p2 = new Primitives();
0763: p2.setArrayAttribute(null);
0764:
0765: workingMemory.insert(p1);
0766: workingMemory.insert(p2);
0767:
0768: workingMemory.fireAllRules();
0769: assertEquals(2, foo.size());
0770:
0771: }
0772:
0773: public void testImportFunctions() throws Exception {
0774: final PackageBuilder builder = new PackageBuilder();
0775: builder.addPackageFromDrl(new InputStreamReader(getClass()
0776: .getResourceAsStream("test_ImportFunctions.drl")));
0777: final Package pkg = builder.getPackage();
0778:
0779: final RuleBase ruleBase = getRuleBase();
0780: ruleBase.addPackage(pkg);
0781: final WorkingMemory workingMemory = ruleBase
0782: .newStatefulSession();
0783: final Cheese cheese = new Cheese("stilton", 15);
0784: workingMemory.insert(cheese);
0785: final List list = new ArrayList();
0786: workingMemory.setGlobal("list", list);
0787: workingMemory.fireAllRules();
0788:
0789: assertEquals(4, list.size());
0790:
0791: assertEquals("rule1", list.get(0));
0792: assertEquals("rule2", list.get(1));
0793: assertEquals("rule3", list.get(2));
0794: assertEquals("rule4", list.get(3));
0795: }
0796:
0797: public void testBasicFrom() throws Exception {
0798: final PackageBuilder builder = new PackageBuilder();
0799: builder.addPackageFromDrl(new InputStreamReader(getClass()
0800: .getResourceAsStream("test_From.drl")));
0801: final Package pkg = builder.getPackage();
0802:
0803: final RuleBase ruleBase = getRuleBase();
0804: ruleBase.addPackage(pkg);
0805:
0806: final WorkingMemory workingMemory = ruleBase
0807: .newStatefulSession();
0808: final List list1 = new ArrayList();
0809: workingMemory.setGlobal("list1", list1);
0810: final List list2 = new ArrayList();
0811: workingMemory.setGlobal("list2", list2);
0812: final List list3 = new ArrayList();
0813: workingMemory.setGlobal("list3", list3);
0814:
0815: final Cheesery cheesery = new Cheesery();
0816: final Cheese stilton = new Cheese("stilton", 12);
0817: final Cheese cheddar = new Cheese("cheddar", 15);
0818: cheesery.addCheese(stilton);
0819: cheesery.addCheese(cheddar);
0820: workingMemory.setGlobal("cheesery", cheesery);
0821: workingMemory.insert(cheesery);
0822:
0823: Person p = new Person("stilton");
0824: workingMemory.insert(p);
0825:
0826: workingMemory.fireAllRules();
0827:
0828: // from using a global
0829: assertEquals(2, list1.size());
0830: assertEquals(cheddar, list1.get(0));
0831: assertEquals(stilton, list1.get(1));
0832:
0833: // from using a declaration
0834: assertEquals(2, list2.size());
0835: assertEquals(cheddar, list2.get(0));
0836: assertEquals(stilton, list2.get(1));
0837:
0838: // from using a declaration
0839: assertEquals(1, list3.size());
0840: assertEquals(stilton, list3.get(0));
0841: }
0842:
0843: public void testFromWithParams() throws Exception {
0844: final PackageBuilder builder = new PackageBuilder();
0845: builder.addPackageFromDrl(new InputStreamReader(getClass()
0846: .getResourceAsStream("test_FromWithParams.drl")));
0847: final Package pkg = builder.getPackage();
0848:
0849: final RuleBase ruleBase = getRuleBase();
0850: ruleBase.addPackage(pkg);
0851:
0852: final WorkingMemory workingMemory = ruleBase
0853: .newStatefulSession();
0854: final List list = new ArrayList();
0855: final Object globalObject = new Object();
0856: workingMemory.setGlobal("list", list);
0857: workingMemory.setGlobal("testObject", new FromTestClass());
0858: workingMemory.setGlobal("globalObject", globalObject);
0859:
0860: final Person bob = new Person("bob");
0861: workingMemory.insert(bob);
0862:
0863: workingMemory.fireAllRules();
0864:
0865: assertEquals(6, list.size());
0866:
0867: final List array = (List) list.get(0);
0868: assertEquals(3, array.size());
0869: final Person p = (Person) array.get(0);
0870: assertSame(p, bob);
0871:
0872: assertEquals(new Integer(42), array.get(1));
0873:
0874: final List nested = (List) array.get(2);
0875: assertEquals("x", nested.get(0));
0876: assertEquals("y", nested.get(1));
0877:
0878: final Map map = (Map) list.get(1);
0879: assertEquals(2, map.keySet().size());
0880:
0881: assertTrue(map.keySet().contains(bob));
0882: assertSame(globalObject, map.get(bob));
0883:
0884: assertTrue(map.keySet().contains("key1"));
0885: final Map nestedMap = (Map) map.get("key1");
0886: assertEquals(1, nestedMap.keySet().size());
0887: assertTrue(nestedMap.keySet().contains("key2"));
0888: assertEquals("value2", nestedMap.get("key2"));
0889:
0890: assertEquals(new Integer(42), list.get(2));
0891: assertEquals("literal", list.get(3));
0892: assertSame(bob, list.get(4));
0893: assertSame(globalObject, list.get(5));
0894: }
0895:
0896: public void testFromWithNewConstructor() throws Exception {
0897: DrlParser parser = new DrlParser();
0898: PackageDescr descr = parser.parse(new InputStreamReader(
0899: getClass().getResourceAsStream(
0900: "test_FromWithNewConstructor.drl")));
0901: PackageBuilder builder = new PackageBuilder();
0902: builder.addPackage(descr);
0903: Package pkg = builder.getPackage();
0904: pkg.checkValidity();
0905: }
0906:
0907: public void testWithInvalidRule() throws Exception {
0908: final PackageBuilder builder = new PackageBuilder();
0909: builder.addPackageFromDrl(new InputStreamReader(getClass()
0910: .getResourceAsStream("invalid_rule.drl")));
0911: final Package pkg = builder.getPackage();
0912: // Mark: please check if the conseqeuence/should/shouldn't be built
0913: // Rule badBoy = pkg.getRules()[0];
0914: // assertFalse(badBoy.isValid());
0915:
0916: RuntimeException runtime = null;
0917: // this should ralph all over the place.
0918: final RuleBase ruleBase = getRuleBase();
0919: try {
0920: ruleBase.addPackage(pkg);
0921: fail("Should have thrown an exception as the rule is NOT VALID.");
0922: } catch (final RuntimeException e) {
0923: assertNotNull(e.getMessage());
0924: runtime = e;
0925: }
0926: assertTrue(builder.getErrors().getErrors().length > 0);
0927:
0928: final String pretty = builder.getErrors().toString();
0929: assertFalse(pretty.equals(""));
0930: assertEquals(pretty, runtime.getMessage());
0931:
0932: }
0933:
0934: public void testErrorLineNumbers() throws Exception {
0935: // this test aims to test semantic errors
0936: // parser errors are another test case
0937: final PackageBuilder builder = new PackageBuilder();
0938: builder.addPackageFromDrl(new InputStreamReader(getClass()
0939: .getResourceAsStream("errors_in_rule.drl")));
0940: final Package pkg = builder.getPackage();
0941:
0942: final DroolsError err = builder.getErrors().getErrors()[0];
0943: final RuleError ruleErr = (RuleError) err;
0944: assertNotNull(ruleErr.getDescr());
0945: assertTrue(ruleErr.getLine() != -1);
0946:
0947: final DroolsError errs[] = builder.getErrors().getErrors();
0948:
0949: assertEquals(3, builder.getErrors().getErrors().length);
0950:
0951: // check that its getting it from the ruleDescr
0952: assertEquals(ruleErr.getLine(), ruleErr.getDescr().getLine());
0953: // check the absolute error line number (there are more).
0954: assertEquals(11, ruleErr.getLine());
0955:
0956: // now check the RHS, not being too specific yet, as long as it has the
0957: // rules line number, not zero
0958: final RuleError rhs = (RuleError) builder.getErrors()
0959: .getErrors()[2];
0960: assertTrue(rhs.getLine() > 7); // not being too specific - may need to
0961: // change this when we rework the error
0962: // reporting
0963:
0964: }
0965:
0966: public void testErrorsParser() throws Exception {
0967: final DrlParser parser = new DrlParser();
0968: assertEquals(0, parser.getErrors().size());
0969: parser.parse(new InputStreamReader(getClass()
0970: .getResourceAsStream("errors_parser_multiple.drl")));
0971: assertTrue(parser.hasErrors());
0972: assertTrue(parser.getErrors().size() > 0);
0973: assertTrue(parser.getErrors().get(0) instanceof ParserError);
0974: final ParserError first = ((ParserError) parser.getErrors()
0975: .get(0));
0976: assertTrue(first.getMessage() != null);
0977: assertFalse(first.getMessage().equals(""));
0978: }
0979:
0980: public void testFunction() throws Exception {
0981: final PackageBuilder builder = new PackageBuilder();
0982: builder
0983: .addPackageFromDrl(new InputStreamReader(getClass()
0984: .getResourceAsStream(
0985: "test_FunctionInConsequence.drl")));
0986: final Package pkg = builder.getPackage();
0987:
0988: final RuleBase ruleBase = getRuleBase();
0989: ruleBase.addPackage(pkg);
0990: final WorkingMemory workingMemory = ruleBase
0991: .newStatefulSession();
0992:
0993: final List list = new ArrayList();
0994: workingMemory.setGlobal("list", list);
0995:
0996: final Cheese stilton = new Cheese("stilton", 5);
0997: workingMemory.insert(stilton);
0998:
0999: workingMemory.fireAllRules();
1000:
1001: assertEquals(new Integer(5), list.get(0));
1002: }
1003:
1004: public void testAssertRetract() throws Exception {
1005: // postponed while I sort out KnowledgeHelperFixer
1006: final PackageBuilder builder = new PackageBuilder();
1007: builder.addPackageFromDrl(new InputStreamReader(getClass()
1008: .getResourceAsStream("assert_retract.drl")));
1009: final Package pkg = builder.getPackage();
1010:
1011: final RuleBase ruleBase = getRuleBase();
1012: ruleBase.addPackage(pkg);
1013: final WorkingMemory workingMemory = ruleBase
1014: .newStatefulSession();
1015:
1016: final List list = new ArrayList();
1017: workingMemory.setGlobal("list", list);
1018:
1019: final PersonInterface person = new Person("michael", "cheese");
1020: person.setStatus("start");
1021: workingMemory.insert(person);
1022: workingMemory.fireAllRules();
1023:
1024: assertEquals(5, list.size());
1025: assertTrue(list.contains("first"));
1026: assertTrue(list.contains("second"));
1027: assertTrue(list.contains("third"));
1028: assertTrue(list.contains("fourth"));
1029: assertTrue(list.contains("fifth"));
1030:
1031: }
1032:
1033: public void testPredicateAsFirstPattern() throws Exception {
1034: final PackageBuilder builder = new PackageBuilder();
1035: builder
1036: .addPackageFromDrl(new InputStreamReader(getClass()
1037: .getResourceAsStream(
1038: "predicate_as_first_pattern.drl")));
1039: final Package pkg = builder.getPackage();
1040:
1041: final RuleBase ruleBase = getRuleBase();
1042: ruleBase.addPackage(pkg);
1043: final WorkingMemory workingMemory = ruleBase
1044: .newStatefulSession();
1045:
1046: final Cheese mussarela = new Cheese("Mussarela", 35);
1047: workingMemory.insert(mussarela);
1048: final Cheese provolone = new Cheese("Provolone", 20);
1049: workingMemory.insert(provolone);
1050:
1051: workingMemory.fireAllRules();
1052:
1053: Assert.assertEquals("The rule is being incorrectly fired", 35,
1054: mussarela.getPrice());
1055: Assert.assertEquals("Rule is incorrectly being fired", 20,
1056: provolone.getPrice());
1057: }
1058:
1059: public void testConsequenceException() throws Exception {
1060: final PackageBuilder builder = new PackageBuilder();
1061: builder.addPackageFromDrl(new InputStreamReader(getClass()
1062: .getResourceAsStream("test_ConsequenceException.drl")));
1063: final Package pkg = builder.getPackage();
1064:
1065: final RuleBase ruleBase = getRuleBase();
1066: ruleBase.addPackage(pkg);
1067: final WorkingMemory workingMemory = ruleBase
1068: .newStatefulSession();
1069:
1070: final Cheese brie = new Cheese("brie", 12);
1071: workingMemory.insert(brie);
1072:
1073: try {
1074: workingMemory.fireAllRules();
1075: fail("Should throw an Exception from the Consequence");
1076: } catch (final Exception e) {
1077: assertEquals("this should throw an exception", e.getCause()
1078: .getMessage());
1079: }
1080: }
1081:
1082: public void testCustomConsequenceException() throws Exception {
1083: final PackageBuilder builder = new PackageBuilder();
1084: builder.addPackageFromDrl(new InputStreamReader(getClass()
1085: .getResourceAsStream("test_ConsequenceException.drl")));
1086: final Package pkg = builder.getPackage();
1087:
1088: RuleBaseConfiguration conf = new RuleBaseConfiguration();
1089: CustomConsequenceExceptionHandler handler = new CustomConsequenceExceptionHandler();
1090: conf.setConsequenceExceptionHandler(handler);
1091:
1092: final RuleBase ruleBase = getRuleBase(conf);
1093: ruleBase.addPackage(pkg);
1094: final WorkingMemory workingMemory = ruleBase
1095: .newStatefulSession();
1096:
1097: final Cheese brie = new Cheese("brie", 12);
1098: workingMemory.insert(brie);
1099:
1100: workingMemory.fireAllRules();
1101:
1102: assertTrue(handler.isCalled());
1103: }
1104:
1105: public static class CustomConsequenceExceptionHandler implements
1106: ConsequenceExceptionHandler {
1107:
1108: private boolean called;
1109:
1110: public void handleException(Activation activation,
1111: WorkingMemory workingMemory, Exception exception) {
1112: this .called = true;
1113: }
1114:
1115: public boolean isCalled() {
1116: return this .called;
1117: }
1118:
1119: }
1120:
1121: public void testFunctionException() throws Exception {
1122: final PackageBuilder builder = new PackageBuilder();
1123: builder.addPackageFromDrl(new InputStreamReader(getClass()
1124: .getResourceAsStream("test_FunctionException.drl")));
1125: final Package pkg = builder.getPackage();
1126:
1127: final RuleBase ruleBase = getRuleBase();
1128: ruleBase.addPackage(pkg);
1129: final WorkingMemory workingMemory = ruleBase
1130: .newStatefulSession();
1131:
1132: final Cheese brie = new Cheese("brie", 12);
1133: workingMemory.insert(brie);
1134:
1135: try {
1136: workingMemory.fireAllRules();
1137: fail("Should throw an Exception from the Function");
1138: } catch (final Exception e) {
1139: assertEquals("this should throw an exception", e.getCause()
1140: .getMessage());
1141: }
1142: }
1143:
1144: public void testEvalException() throws Exception {
1145: final PackageBuilder builder = new PackageBuilder();
1146: builder.addPackageFromDrl(new InputStreamReader(getClass()
1147: .getResourceAsStream("test_EvalException.drl")));
1148: final Package pkg = builder.getPackage();
1149:
1150: final RuleBase ruleBase = getRuleBase();
1151: ruleBase.addPackage(pkg);
1152: final WorkingMemory workingMemory = ruleBase
1153: .newStatefulSession();
1154:
1155: final Cheese brie = new Cheese("brie", 12);
1156:
1157: try {
1158: workingMemory.insert(brie);
1159: workingMemory.fireAllRules();
1160: fail("Should throw an Exception from the Eval");
1161: } catch (final Exception e) {
1162: assertEquals("this should throw an exception", e.getCause()
1163: .getMessage());
1164: }
1165: }
1166:
1167: public void testPredicateException() throws Exception {
1168: final PackageBuilder builder = new PackageBuilder();
1169: builder.addPackageFromDrl(new InputStreamReader(getClass()
1170: .getResourceAsStream("test_PredicateException.drl")));
1171: final Package pkg = builder.getPackage();
1172:
1173: final RuleBase ruleBase = getRuleBase();
1174: ruleBase.addPackage(pkg);
1175: final WorkingMemory workingMemory = ruleBase
1176: .newStatefulSession();
1177:
1178: final Cheese brie = new Cheese("brie", 12);
1179:
1180: try {
1181: workingMemory.insert(brie);
1182: workingMemory.fireAllRules();
1183: fail("Should throw an Exception from the Predicate");
1184: } catch (final Exception e) {
1185: assertEquals("this should throw an exception", e.getCause()
1186: .getMessage());
1187: }
1188: }
1189:
1190: public void testReturnValueException() throws Exception {
1191: final PackageBuilder builder = new PackageBuilder();
1192: builder.addPackageFromDrl(new InputStreamReader(getClass()
1193: .getResourceAsStream("test_ReturnValueException.drl")));
1194: final Package pkg = builder.getPackage();
1195:
1196: final RuleBase ruleBase = getRuleBase();
1197: ruleBase.addPackage(pkg);
1198: final WorkingMemory workingMemory = ruleBase
1199: .newStatefulSession();
1200:
1201: final Cheese brie = new Cheese("brie", 12);
1202:
1203: try {
1204: workingMemory.insert(brie);
1205: workingMemory.fireAllRules();
1206: fail("Should throw an Exception from the ReturnValue");
1207: } catch (final Exception e) {
1208: assertTrue(e.getCause().getMessage().endsWith(
1209: "this should throw an exception"));
1210: }
1211: }
1212:
1213: public void testMultiRestrictionFieldConstraint() throws Exception {
1214: final PackageBuilder builder = new PackageBuilder();
1215: builder.addPackageFromDrl(new InputStreamReader(getClass()
1216: .getResourceAsStream(
1217: "test_MultiRestrictionFieldConstraint.drl")));
1218: final Package pkg = builder.getPackage();
1219:
1220: final RuleBase ruleBase = getRuleBase();
1221: ruleBase.addPackage(pkg);
1222: final WorkingMemory workingMemory = ruleBase
1223: .newStatefulSession();
1224:
1225: final List list1 = new ArrayList();
1226: workingMemory.setGlobal("list1", list1);
1227: final List list2 = new ArrayList();
1228: workingMemory.setGlobal("list2", list2);
1229: final List list3 = new ArrayList();
1230: workingMemory.setGlobal("list3", list3);
1231: final List list4 = new ArrayList();
1232: workingMemory.setGlobal("list4", list4);
1233:
1234: final Person youngChili1 = new Person("young chili1");
1235: youngChili1.setAge(12);
1236: youngChili1.setHair("blue");
1237: final Person youngChili2 = new Person("young chili2");
1238: youngChili2.setAge(25);
1239: youngChili2.setHair("purple");
1240:
1241: final Person chili1 = new Person("chili1");
1242: chili1.setAge(35);
1243: chili1.setHair("red");
1244:
1245: final Person chili2 = new Person("chili2");
1246: chili2.setAge(38);
1247: chili2.setHair("indigigo");
1248:
1249: final Person oldChili1 = new Person("old chili2");
1250: oldChili1.setAge(45);
1251: oldChili1.setHair("green");
1252:
1253: final Person oldChili2 = new Person("old chili2");
1254: oldChili2.setAge(48);
1255: oldChili2.setHair("blue");
1256:
1257: workingMemory.insert(youngChili1);
1258: workingMemory.insert(youngChili2);
1259: workingMemory.insert(chili1);
1260: workingMemory.insert(chili2);
1261: workingMemory.insert(oldChili1);
1262: workingMemory.insert(oldChili2);
1263:
1264: workingMemory.fireAllRules();
1265:
1266: assertEquals(1, list1.size());
1267: assertTrue(list1.contains(chili1));
1268:
1269: assertEquals(2, list2.size());
1270: assertTrue(list2.contains(chili1));
1271: assertTrue(list2.contains(chili2));
1272:
1273: assertEquals(2, list3.size());
1274: assertTrue(list3.contains(youngChili1));
1275: assertTrue(list3.contains(youngChili2));
1276:
1277: assertEquals(2, list4.size());
1278: assertTrue(list4.contains(youngChili1));
1279: assertTrue(list4.contains(chili1));
1280: }
1281:
1282: public void testDumpers() throws Exception {
1283: final DrlParser parser = new DrlParser();
1284: final PackageDescr pkg = parser.parse(new InputStreamReader(
1285: getClass().getResourceAsStream("test_Dumpers.drl")));
1286:
1287: PackageBuilder builder = new PackageBuilder();
1288: builder.addPackage(pkg);
1289:
1290: RuleBase ruleBase = getRuleBase();
1291: ruleBase.addPackage(builder.getPackage());
1292: WorkingMemory workingMemory = ruleBase.newStatefulSession();
1293:
1294: List list = new ArrayList();
1295: workingMemory.setGlobal("list", list);
1296:
1297: final Cheese brie = new Cheese("brie", 12);
1298: workingMemory.insert(brie);
1299:
1300: workingMemory.fireAllRules();
1301:
1302: assertEquals(3, list.size());
1303: assertEquals("3 1", list.get(0));
1304: assertEquals("MAIN", list.get(1));
1305: assertEquals("1 1", list.get(2));
1306:
1307: final DrlDumper drlDumper = new DrlDumper();
1308: final String drlResult = drlDumper.dump(pkg);
1309: builder = new PackageBuilder();
1310: builder.addPackageFromDrl(new StringReader(drlResult));
1311:
1312: ruleBase = getRuleBase();
1313: ruleBase.addPackage(builder.getPackage());
1314: workingMemory = ruleBase.newStatefulSession();
1315:
1316: list = new ArrayList();
1317: workingMemory.setGlobal("list", list);
1318:
1319: workingMemory.insert(brie);
1320:
1321: workingMemory.fireAllRules();
1322:
1323: assertEquals(3, list.size());
1324: assertEquals("3 1", list.get(0));
1325: assertEquals("MAIN", list.get(1));
1326: assertEquals("1 1", list.get(2));
1327:
1328: final XmlDumper xmlDumper = new XmlDumper();
1329: final String xmlResult = xmlDumper.dump(pkg);
1330:
1331: // System.out.println( xmlResult );
1332:
1333: builder = new PackageBuilder();
1334: builder.addPackageFromXml(new StringReader(xmlResult));
1335:
1336: ruleBase = getRuleBase();
1337: ruleBase.addPackage(builder.getPackage());
1338: workingMemory = ruleBase.newStatefulSession();
1339:
1340: list = new ArrayList();
1341: workingMemory.setGlobal("list", list);
1342:
1343: workingMemory.insert(brie);
1344:
1345: workingMemory.fireAllRules();
1346:
1347: assertEquals(3, list.size());
1348: assertEquals("3 1", list.get(0));
1349: assertEquals("MAIN", list.get(1));
1350: assertEquals("1 1", list.get(2));
1351: }
1352:
1353: public void testContainsCheese() throws Exception {
1354: final PackageBuilder builder = new PackageBuilder();
1355: builder.addPackageFromDrl(new InputStreamReader(getClass()
1356: .getResourceAsStream("test_ContainsCheese.drl")));
1357: final Package pkg = builder.getPackage();
1358:
1359: final RuleBase ruleBase = getRuleBase();
1360: ruleBase.addPackage(pkg);
1361: final WorkingMemory workingMemory = ruleBase
1362: .newStatefulSession();
1363:
1364: final List list = new ArrayList();
1365: workingMemory.setGlobal("list", list);
1366:
1367: final Cheese stilton = new Cheese("stilton", 12);
1368: workingMemory.insert(stilton);
1369: final Cheese brie = new Cheese("brie", 10);
1370: workingMemory.insert(brie);
1371:
1372: final Cheesery cheesery = new Cheesery();
1373: cheesery.getCheeses().add(stilton);
1374: workingMemory.insert(cheesery);
1375:
1376: workingMemory.fireAllRules();
1377:
1378: assertEquals(2, list.size());
1379:
1380: assertEquals(stilton, list.get(0));
1381: assertEquals(brie, list.get(1));
1382: }
1383:
1384: public void testStaticFieldReference() throws Exception {
1385: final PackageBuilder builder = new PackageBuilder();
1386: builder.addPackageFromDrl(new InputStreamReader(getClass()
1387: .getResourceAsStream("test_StaticField.drl")));
1388: final Package pkg = builder.getPackage();
1389:
1390: final RuleBase ruleBase = getRuleBase();
1391: ruleBase.addPackage(pkg);
1392: final WorkingMemory workingMemory = ruleBase
1393: .newStatefulSession();
1394:
1395: final List list = new ArrayList();
1396: workingMemory.setGlobal("list", list);
1397:
1398: final Cheesery cheesery1 = new Cheesery();
1399: cheesery1.setStatus(Cheesery.SELLING_CHEESE);
1400: cheesery1.setMaturity(Maturity.OLD);
1401: workingMemory.insert(cheesery1);
1402:
1403: final Cheesery cheesery2 = new Cheesery();
1404: cheesery2.setStatus(Cheesery.MAKING_CHEESE);
1405: cheesery2.setMaturity(Maturity.YOUNG);
1406: workingMemory.insert(cheesery2);
1407:
1408: workingMemory.fireAllRules();
1409:
1410: assertEquals(2, list.size());
1411:
1412: assertEquals(cheesery1, list.get(0));
1413: assertEquals(cheesery2, list.get(1));
1414: }
1415:
1416: public void testDuplicateRuleNames() throws Exception {
1417: PackageBuilder builder = new PackageBuilder();
1418: builder.addPackageFromDrl(new InputStreamReader(getClass()
1419: .getResourceAsStream("test_DuplicateRuleName1.drl")));
1420:
1421: final RuleBase ruleBase = getRuleBase();
1422: ruleBase.addPackage(builder.getPackage());
1423:
1424: builder = new PackageBuilder();
1425: builder.addPackageFromDrl(new InputStreamReader(getClass()
1426: .getResourceAsStream("test_DuplicateRuleName2.drl")));
1427: ruleBase.addPackage(builder.getPackage());
1428:
1429: // @todo: this is from JBRULES-394 - maybe we should test more stuff
1430: // here?
1431:
1432: }
1433:
1434: public void testNullValuesIndexing() throws Exception {
1435: final Reader reader = new InputStreamReader(getClass()
1436: .getResourceAsStream("test_NullValuesIndexing.drl"));
1437:
1438: final PackageBuilder builder = new PackageBuilder();
1439: builder.addPackageFromDrl(reader);
1440: final Package pkg1 = builder.getPackage();
1441:
1442: final RuleBase ruleBase = getRuleBase();
1443: ruleBase.addPackage(pkg1);
1444: final WorkingMemory workingMemory = ruleBase
1445: .newStatefulSession();
1446:
1447: // Adding person with null name and likes attributes
1448: final PersonInterface bob = new Person(null, null);
1449: bob.setStatus("P1");
1450: final PersonInterface pete = new Person(null, null);
1451: bob.setStatus("P2");
1452: workingMemory.insert(bob);
1453: workingMemory.insert(pete);
1454:
1455: workingMemory.fireAllRules();
1456:
1457: Assert.assertEquals(
1458: "Indexing with null values is not working correctly.",
1459: "OK", bob.getStatus());
1460: Assert.assertEquals(
1461: "Indexing with null values is not working correctly.",
1462: "OK", pete.getStatus());
1463:
1464: }
1465:
1466: public void testSerializable() throws Exception {
1467:
1468: final Reader reader = new InputStreamReader(getClass()
1469: .getResourceAsStream("test_Serializable.drl"));
1470:
1471: final PackageBuilder builder = new PackageBuilder();
1472: builder.addPackageFromDrl(reader);
1473: final Package pkg = builder.getPackage();
1474:
1475: assertEquals(0, builder.getErrors().getErrors().length);
1476:
1477: RuleBase ruleBase = getRuleBase();// RuleBaseFactory.newRuleBase();
1478:
1479: ruleBase.addPackage(pkg);
1480:
1481: Map map = new HashMap();
1482: map.put("x", ruleBase);
1483: final byte[] ast = serializeOut(map);
1484: map = (Map) serializeIn(ast);
1485: ruleBase = (RuleBase) map.get("x");
1486: final Rule[] rules = ruleBase.getPackages()[0].getRules();
1487: assertEquals(4, rules.length);
1488:
1489: assertEquals("match Person 1", rules[0].getName());
1490: assertEquals("match Person 2", rules[1].getName());
1491: assertEquals("match Person 3", rules[2].getName());
1492: assertEquals("match Integer", rules[3].getName());
1493:
1494: WorkingMemory workingMemory = ruleBase.newStatefulSession();
1495:
1496: workingMemory.setGlobal("list", new ArrayList());
1497:
1498: final Person bob = new Person("bob");
1499: workingMemory.insert(bob);
1500:
1501: final byte[] wm = serializeOut(workingMemory);
1502:
1503: workingMemory = ruleBase
1504: .newStatefulSession(new ByteArrayInputStream(wm));
1505:
1506: assertEquals(1, IteratorToList.convert(
1507: workingMemory.iterateObjects()).size());
1508: assertEquals(bob, IteratorToList.convert(
1509: workingMemory.iterateObjects()).get(0));
1510:
1511: assertEquals(2, workingMemory.getAgenda().agendaSize());
1512:
1513: workingMemory.fireAllRules();
1514:
1515: final List list = (List) workingMemory.getGlobal("list");
1516:
1517: assertEquals(3, list.size());
1518: // because of agenda-groups
1519: assertEquals(new Integer(4), list.get(0));
1520:
1521: assertEquals(2, IteratorToList.convert(
1522: workingMemory.iterateObjects()).size());
1523: assertTrue(IteratorToList.convert(
1524: workingMemory.iterateObjects()).contains(bob));
1525: assertTrue(IteratorToList.convert(
1526: workingMemory.iterateObjects()).contains(
1527: new Person("help")));
1528: }
1529:
1530: public void testEmptyRule() throws Exception {
1531: final PackageBuilder builder = new PackageBuilder();
1532: builder.addPackageFromDrl(new InputStreamReader(getClass()
1533: .getResourceAsStream("test_EmptyRule.drl")));
1534: final Package pkg = builder.getPackage();
1535:
1536: final RuleBase ruleBase = getRuleBase();
1537: ruleBase.addPackage(pkg);
1538: final WorkingMemory workingMemory = ruleBase
1539: .newStatefulSession();
1540:
1541: final List list = new ArrayList();
1542: workingMemory.setGlobal("list", list);
1543:
1544: workingMemory.fireAllRules();
1545:
1546: assertTrue(list.contains("fired1"));
1547: assertTrue(list.contains("fired2"));
1548: }
1549:
1550: public void testjustEval() throws Exception {
1551: final PackageBuilder builder = new PackageBuilder();
1552: builder.addPackageFromDrl(new InputStreamReader(getClass()
1553: .getResourceAsStream("test_NoPatterns.drl")));
1554: final Package pkg = builder.getPackage();
1555:
1556: final RuleBase ruleBase = getRuleBase();
1557: ruleBase.addPackage(pkg);
1558: final WorkingMemory workingMemory = ruleBase
1559: .newStatefulSession();
1560:
1561: final List list = new ArrayList();
1562: workingMemory.setGlobal("list", list);
1563:
1564: workingMemory.fireAllRules();
1565:
1566: assertTrue(list.contains("fired1"));
1567: assertTrue(list.contains("fired3"));
1568: }
1569:
1570: public void testOrWithBinding() throws Exception {
1571:
1572: final PackageBuilder builder = new PackageBuilder();
1573: builder.addPackageFromDrl(new InputStreamReader(getClass()
1574: .getResourceAsStream("test_OrWithBindings.drl")));
1575: final Package pkg = builder.getPackage();
1576:
1577: final RuleBase ruleBase = getRuleBase();
1578: ruleBase.addPackage(pkg);
1579: final WorkingMemory workingMemory = ruleBase
1580: .newStatefulSession();
1581:
1582: final List list = new ArrayList();
1583: workingMemory.setGlobal("results", list);
1584:
1585: final Person hola = new Person("hola");
1586: workingMemory.insert(hola);
1587:
1588: workingMemory.fireAllRules();
1589:
1590: assertEquals(0, list.size());
1591: workingMemory.insert(new State("x"));
1592:
1593: workingMemory.fireAllRules();
1594:
1595: assertEquals(1, list.size());
1596: assertTrue(list.contains(hola));
1597:
1598: }
1599:
1600: protected Object serializeIn(final byte[] bytes)
1601: throws IOException, ClassNotFoundException {
1602: final ObjectInput in = new ObjectInputStream(
1603: new ByteArrayInputStream(bytes));
1604: final Object obj = in.readObject();
1605: in.close();
1606: return obj;
1607: }
1608:
1609: protected byte[] serializeOut(final Object obj) throws IOException {
1610: // Serialize to a byte array
1611: final ByteArrayOutputStream bos = new ByteArrayOutputStream();
1612: final ObjectOutput out = new ObjectOutputStream(bos);
1613: out.writeObject(obj);
1614: out.close();
1615:
1616: // Get the bytes of the serialized object
1617: final byte[] bytes = bos.toByteArray();
1618: return bytes;
1619: }
1620:
1621: public void testJoinNodeModifyObject() throws Exception {
1622: final Reader reader = new InputStreamReader(getClass()
1623: .getResourceAsStream("test_JoinNodeModifyObject.drl"));
1624:
1625: final PackageBuilder builder = new PackageBuilder();
1626: builder.addPackageFromDrl(reader);
1627: final Package pkg1 = builder.getPackage();
1628:
1629: final RuleBase ruleBase = getRuleBase();
1630: ruleBase.addPackage(pkg1);
1631: final WorkingMemory workingMemory = ruleBase
1632: .newStatefulSession();
1633:
1634: final List orderedFacts = new ArrayList();
1635: final List errors = new ArrayList();
1636:
1637: workingMemory.setGlobal("orderedNumbers", orderedFacts);
1638: workingMemory.setGlobal("errors", errors);
1639:
1640: final int MAX = 5;
1641: for (int i = 1; i <= MAX; i++) {
1642: final IndexedNumber n = new IndexedNumber(i, MAX - i + 1);
1643: workingMemory.insert(n);
1644: }
1645: workingMemory.fireAllRules();
1646:
1647: Assert.assertTrue("Processing generated errors: "
1648: + errors.toString(), errors.isEmpty());
1649:
1650: for (int i = 1; i <= MAX; i++) {
1651: final IndexedNumber n = (IndexedNumber) orderedFacts
1652: .get(i - 1);
1653: Assert
1654: .assertEquals("Fact is out of order", i, n
1655: .getIndex());
1656: }
1657: }
1658:
1659: public void testQuery2() throws Exception {
1660: final PackageBuilder builder = new PackageBuilder();
1661: builder.addPackageFromDrl(new InputStreamReader(getClass()
1662: .getResourceAsStream("test_Query.drl")));
1663:
1664: final RuleBase ruleBase = getRuleBase();
1665: ruleBase.addPackage(builder.getPackage());
1666:
1667: final WorkingMemory workingMemory = ruleBase
1668: .newStatefulSession();
1669: workingMemory.fireAllRules();
1670:
1671: final QueryResults results = workingMemory
1672: .getQueryResults("assertedobjquery");
1673: assertEquals(1, results.size());
1674: assertEquals(new InsertedObject("value1"), results.get(0)
1675: .get(0));
1676: }
1677:
1678: public void testQueryWithParams() throws Exception {
1679: final PackageBuilder builder = new PackageBuilder();
1680: builder.addPackageFromDrl(new InputStreamReader(getClass()
1681: .getResourceAsStream("test_QueryWithParams.drl")));
1682:
1683: final RuleBase ruleBase = getRuleBase();
1684: ruleBase.addPackage(builder.getPackage());
1685:
1686: final WorkingMemory workingMemory = ruleBase
1687: .newStatefulSession();
1688: workingMemory.fireAllRules();
1689:
1690: QueryResults results = workingMemory.getQueryResults(
1691: "assertedobjquery", new String[] { "value1" });
1692: assertEquals(1, results.size());
1693: assertEquals(new InsertedObject("value1"), results.get(0)
1694: .get(0));
1695:
1696: results = workingMemory.getQueryResults("assertedobjquery",
1697: new String[] { "value3" });
1698: assertEquals(0, results.size());
1699:
1700: results = workingMemory.getQueryResults("assertedobjquery2",
1701: new String[] { null, "value2" });
1702: assertEquals(1, results.size());
1703: assertEquals(new InsertedObject("value2"), results.get(0)
1704: .get(0));
1705:
1706: results = workingMemory.getQueryResults("assertedobjquery2",
1707: new String[] { "value3", "value2" });
1708: assertEquals(1, results.size());
1709: assertEquals(new InsertedObject("value2"), results.get(0)
1710: .get(0));
1711: }
1712:
1713: public void testTwoQuerries() throws Exception {
1714: // @see JBRULES-410 More than one Query definition causes an incorrect
1715: // Rete network to be built.
1716:
1717: final PackageBuilder builder = new PackageBuilder();
1718: builder.addPackageFromDrl(new InputStreamReader(getClass()
1719: .getResourceAsStream("test_TwoQuerries.drl")));
1720: final Package pkg = builder.getPackage();
1721:
1722: final RuleBase ruleBase = getRuleBase();
1723: ruleBase.addPackage(pkg);
1724: final WorkingMemory workingMemory = ruleBase
1725: .newStatefulSession();
1726:
1727: final Cheese stilton = new Cheese("stinky", 5);
1728: workingMemory.insert(stilton);
1729: final Person per1 = new Person("stinker", "smelly feet", 70);
1730: final Person per2 = new Person("skunky", "smelly armpits", 40);
1731:
1732: workingMemory.insert(per1);
1733: workingMemory.insert(per2);
1734:
1735: QueryResults results = workingMemory
1736: .getQueryResults("find stinky cheeses");
1737: assertEquals(1, results.size());
1738:
1739: results = workingMemory.getQueryResults("find pensioners");
1740: assertEquals(1, results.size());
1741: }
1742:
1743: public void testInsurancePricingExample() throws Exception {
1744: final Reader reader = new InputStreamReader(getClass()
1745: .getResourceAsStream("insurance_pricing_example.drl"));
1746: final RuleBase ruleBase = loadRuleBase(reader);
1747: final WorkingMemory wm = ruleBase.newStatefulSession();
1748:
1749: // now create some test data
1750: final Driver driver = new Driver();
1751: final Policy policy = new Policy();
1752:
1753: wm.insert(driver);
1754: wm.insert(policy);
1755:
1756: wm.fireAllRules();
1757:
1758: assertEquals(120, policy.getBasePrice());
1759: }
1760:
1761: public void testLLR() throws Exception {
1762:
1763: // read in the source
1764: final Reader reader = new InputStreamReader(getClass()
1765: .getResourceAsStream("test_JoinNodeModifyTuple.drl"));
1766: final RuleBase ruleBase = loadRuleBase(reader);
1767:
1768: final WorkingMemory wm = ruleBase.newStatefulSession();
1769:
1770: // 1st time
1771: org.drools.Target tgt = new org.drools.Target();
1772: tgt.setLabel("Santa-Anna");
1773: tgt.setLat(new Float(60.26544f));
1774: tgt.setLon(new Float(28.952137f));
1775: tgt.setCourse(new Float(145.0f));
1776: tgt.setSpeed(new Float(12.0f));
1777: tgt.setTime(new Float(1.8666667f));
1778: wm.insert(tgt);
1779:
1780: tgt = new org.drools.Target();
1781: tgt.setLabel("Santa-Maria");
1782: tgt.setLat(new Float(60.236874f));
1783: tgt.setLon(new Float(28.992579f));
1784: tgt.setCourse(new Float(325.0f));
1785: tgt.setSpeed(new Float(8.0f));
1786: tgt.setTime(new Float(1.8666667f));
1787: wm.insert(tgt);
1788:
1789: wm.fireAllRules();
1790:
1791: // 2nd time
1792: tgt = new org.drools.Target();
1793: tgt.setLabel("Santa-Anna");
1794: tgt.setLat(new Float(60.265343f));
1795: tgt.setLon(new Float(28.952267f));
1796: tgt.setCourse(new Float(145.0f));
1797: tgt.setSpeed(new Float(12.0f));
1798: tgt.setTime(new Float(1.9f));
1799: wm.insert(tgt);
1800:
1801: tgt = new org.drools.Target();
1802: tgt.setLabel("Santa-Maria");
1803: tgt.setLat(new Float(60.236935f));
1804: tgt.setLon(new Float(28.992493f));
1805: tgt.setCourse(new Float(325.0f));
1806: tgt.setSpeed(new Float(8.0f));
1807: tgt.setTime(new Float(1.9f));
1808: wm.insert(tgt);
1809:
1810: wm.fireAllRules();
1811:
1812: // 3d time
1813: tgt = new org.drools.Target();
1814: tgt.setLabel("Santa-Anna");
1815: tgt.setLat(new Float(60.26525f));
1816: tgt.setLon(new Float(28.952396f));
1817: tgt.setCourse(new Float(145.0f));
1818: tgt.setSpeed(new Float(12.0f));
1819: tgt.setTime(new Float(1.9333333f));
1820: wm.insert(tgt);
1821:
1822: tgt = new org.drools.Target();
1823: tgt.setLabel("Santa-Maria");
1824: tgt.setLat(new Float(60.236996f));
1825: tgt.setLon(new Float(28.992405f));
1826: tgt.setCourse(new Float(325.0f));
1827: tgt.setSpeed(new Float(8.0f));
1828: tgt.setTime(new Float(1.9333333f));
1829: wm.insert(tgt);
1830:
1831: wm.fireAllRules();
1832:
1833: // 4th time
1834: tgt = new org.drools.Target();
1835: tgt.setLabel("Santa-Anna");
1836: tgt.setLat(new Float(60.265163f));
1837: tgt.setLon(new Float(28.952526f));
1838: tgt.setCourse(new Float(145.0f));
1839: tgt.setSpeed(new Float(12.0f));
1840: tgt.setTime(new Float(1.9666667f));
1841: wm.insert(tgt);
1842:
1843: tgt = new org.drools.Target();
1844: tgt.setLabel("Santa-Maria");
1845: tgt.setLat(new Float(60.237057f));
1846: tgt.setLon(new Float(28.99232f));
1847: tgt.setCourse(new Float(325.0f));
1848: tgt.setSpeed(new Float(8.0f));
1849: tgt.setTime(new Float(1.9666667f));
1850: wm.insert(tgt);
1851:
1852: wm.fireAllRules();
1853: }
1854:
1855: public void testDoubleQueryWithExists() throws Exception {
1856: final PackageBuilder builder = new PackageBuilder();
1857: builder
1858: .addPackageFromDrl(new InputStreamReader(getClass()
1859: .getResourceAsStream(
1860: "test_DoubleQueryWithExists.drl")));
1861: final Package pkg = builder.getPackage();
1862:
1863: final RuleBase ruleBase = getRuleBase();
1864: ruleBase.addPackage(pkg);
1865: final WorkingMemory workingMemory = ruleBase
1866: .newStatefulSession();
1867:
1868: final Person p1 = new Person("p1", "stilton", 20);
1869: p1.setStatus("europe");
1870: final FactHandle c1FactHandle = workingMemory.insert(p1);
1871: final Person p2 = new Person("p2", "stilton", 30);
1872: p2.setStatus("europe");
1873: final FactHandle c2FactHandle = workingMemory.insert(p2);
1874: final Person p3 = new Person("p3", "stilton", 40);
1875: p3.setStatus("europe");
1876: final FactHandle c3FactHandle = workingMemory.insert(p3);
1877: workingMemory.fireAllRules();
1878:
1879: QueryResults queryResults = workingMemory
1880: .getQueryResults("2 persons with the same status");
1881: assertEquals(2, queryResults.size());
1882:
1883: // europe=[ 1, 2 ], america=[ 3 ]
1884: p3.setStatus("america");
1885: workingMemory.update(c3FactHandle, p3);
1886: workingMemory.fireAllRules();
1887: queryResults = workingMemory
1888: .getQueryResults("2 persons with the same status");
1889: assertEquals(1, queryResults.size());
1890:
1891: // europe=[ 1 ], america=[ 2, 3 ]
1892: p2.setStatus("america");
1893: workingMemory.update(c2FactHandle, p2);
1894: workingMemory.fireAllRules();
1895: queryResults = workingMemory
1896: .getQueryResults("2 persons with the same status");
1897: assertEquals(1, queryResults.size());
1898:
1899: // europe=[ ], america=[ 1, 2, 3 ]
1900: p1.setStatus("america");
1901: workingMemory.update(c1FactHandle, p1);
1902: workingMemory.fireAllRules();
1903: queryResults = workingMemory
1904: .getQueryResults("2 persons with the same status");
1905: assertEquals(2, queryResults.size());
1906:
1907: // europe=[ 2 ], america=[ 1, 3 ]
1908: p2.setStatus("europe");
1909: workingMemory.update(c2FactHandle, p2);
1910: workingMemory.fireAllRules();
1911: queryResults = workingMemory
1912: .getQueryResults("2 persons with the same status");
1913: assertEquals(1, queryResults.size());
1914:
1915: // europe=[ 1, 2 ], america=[ 3 ]
1916: p1.setStatus("europe");
1917: workingMemory.update(c1FactHandle, p1);
1918: workingMemory.fireAllRules();
1919: queryResults = workingMemory
1920: .getQueryResults("2 persons with the same status");
1921: assertEquals(1, queryResults.size());
1922:
1923: // europe=[ 1, 2, 3 ], america=[ ]
1924: p3.setStatus("europe");
1925: workingMemory.update(c3FactHandle, p3);
1926: workingMemory.fireAllRules();
1927: queryResults = workingMemory
1928: .getQueryResults("2 persons with the same status");
1929: assertEquals(2, queryResults.size());
1930: }
1931:
1932: public void testFunctionWithPrimitives() throws Exception {
1933: final PackageBuilder builder = new PackageBuilder();
1934: builder
1935: .addPackageFromDrl(new InputStreamReader(getClass()
1936: .getResourceAsStream(
1937: "test_FunctionWithPrimitives.drl")));
1938: final Package pkg = builder.getPackage();
1939:
1940: final RuleBase ruleBase = getRuleBase();
1941: ruleBase.addPackage(pkg);
1942: final WorkingMemory workingMemory = ruleBase
1943: .newStatefulSession();
1944:
1945: final List list = new ArrayList();
1946: workingMemory.setGlobal("list", list);
1947:
1948: final Cheese stilton = new Cheese("stilton", 5);
1949: workingMemory.insert(stilton);
1950:
1951: workingMemory.fireAllRules();
1952:
1953: assertEquals(new Integer(10), list.get(0));
1954: }
1955:
1956: public void testReturnValueAndGlobal() throws Exception {
1957:
1958: final PackageBuilder builder = new PackageBuilder();
1959: builder.addPackageFromDrl(new InputStreamReader(getClass()
1960: .getResourceAsStream("test_ReturnValueAndGlobal.drl")));
1961: final Package pkg = builder.getPackage();
1962:
1963: final RuleBase ruleBase = getRuleBase();
1964: ruleBase.addPackage(pkg);
1965: final WorkingMemory workingMemory = ruleBase
1966: .newStatefulSession();
1967:
1968: final List matchlist = new ArrayList();
1969: workingMemory.setGlobal("matchingList", matchlist);
1970:
1971: final List nonmatchlist = new ArrayList();
1972: workingMemory.setGlobal("nonMatchingList", nonmatchlist);
1973:
1974: workingMemory.setGlobal("cheeseType", "stilton");
1975:
1976: final Cheese stilton1 = new Cheese("stilton", 5);
1977: final Cheese stilton2 = new Cheese("stilton", 7);
1978: final Cheese brie = new Cheese("brie", 4);
1979: workingMemory.insert(stilton1);
1980: workingMemory.insert(stilton2);
1981: workingMemory.insert(brie);
1982:
1983: workingMemory.fireAllRules();
1984:
1985: assertEquals(2, matchlist.size());
1986: assertEquals(1, nonmatchlist.size());
1987: }
1988:
1989: public void testDeclaringAndUsingBindsInSamePattern()
1990: throws Exception {
1991: final RuleBaseConfiguration config = new RuleBaseConfiguration();
1992: config.setRemoveIdentities(true);
1993:
1994: final PackageBuilder builder = new PackageBuilder();
1995: builder
1996: .addPackageFromDrl(new InputStreamReader(
1997: getClass()
1998: .getResourceAsStream(
1999: "test_DeclaringAndUsingBindsInSamePattern.drl")));
2000: final Package pkg = builder.getPackage();
2001:
2002: final RuleBase ruleBase = getRuleBase(config);
2003: ruleBase.addPackage(pkg);
2004: final WorkingMemory workingMemory = ruleBase
2005: .newStatefulSession();
2006:
2007: final List sensors = new ArrayList();
2008:
2009: workingMemory.setGlobal("sensors", sensors);
2010:
2011: final Sensor sensor1 = new Sensor(100, 150);
2012: workingMemory.insert(sensor1);
2013: workingMemory.fireAllRules();
2014: assertEquals(0, sensors.size());
2015:
2016: final Sensor sensor2 = new Sensor(200, 150);
2017: workingMemory.insert(sensor2);
2018: workingMemory.fireAllRules();
2019: assertEquals(3, sensors.size());
2020: }
2021:
2022: public void testMissingImports() {
2023: try {
2024: final PackageBuilder builder = new PackageBuilder();
2025: builder.addPackageFromDrl(new InputStreamReader(getClass()
2026: .getResourceAsStream("test_missing_import.drl")));
2027: final Package pkg = builder.getPackage();
2028:
2029: final RuleBase ruleBase = getRuleBase();
2030: ruleBase.addPackage(pkg);
2031:
2032: Assert.fail("Should have thrown an InvalidRulePackage");
2033: } catch (final InvalidRulePackage e) {
2034: // everything fine
2035: } catch (final Exception e) {
2036: e.printStackTrace();
2037: Assert
2038: .fail("Should have thrown an InvalidRulePackage Exception instead of "
2039: + e.getMessage());
2040: }
2041: }
2042:
2043: public void testNestedConditionalElements() throws Exception {
2044:
2045: final PackageBuilder builder = new PackageBuilder();
2046: builder.addPackageFromDrl(new InputStreamReader(getClass()
2047: .getResourceAsStream(
2048: "test_NestedConditionalElements.drl")));
2049: final Package pkg = builder.getPackage();
2050:
2051: final RuleBase ruleBase = getRuleBase();
2052: ruleBase.addPackage(pkg);
2053: final WorkingMemory workingMemory = ruleBase
2054: .newStatefulSession();
2055:
2056: final List list = new ArrayList();
2057: workingMemory.setGlobal("results", list);
2058:
2059: final State state = new State("SP");
2060: workingMemory.insert(state);
2061:
2062: final Person bob = new Person("Bob");
2063: bob.setStatus(state.getState());
2064: bob.setLikes("stilton");
2065: workingMemory.insert(bob);
2066:
2067: workingMemory.fireAllRules();
2068:
2069: assertEquals(0, list.size());
2070:
2071: workingMemory.insert(new Cheese(bob.getLikes(), 10));
2072: workingMemory.fireAllRules();
2073:
2074: assertEquals(1, list.size());
2075: }
2076:
2077: public void testDeclarationUsage() throws Exception {
2078:
2079: try {
2080: final PackageBuilder builder = new PackageBuilder();
2081: builder.addPackageFromDrl(new InputStreamReader(getClass()
2082: .getResourceAsStream("test_DeclarationUsage.drl")));
2083: final Package pkg = builder.getPackage();
2084:
2085: final RuleBase ruleBase = getRuleBase();
2086: ruleBase.addPackage(pkg);
2087:
2088: fail("Should have trown an exception");
2089: } catch (final InvalidRulePackage e) {
2090: // success ... correct exception thrown
2091: } catch (final Exception e) {
2092: e.printStackTrace();
2093: fail("Wrong exception raised: " + e.getMessage());
2094: }
2095: }
2096:
2097: public void testUnbalancedTrees() throws Exception {
2098: final PackageBuilder builder = new PackageBuilder();
2099: builder.addPackageFromDrl(new InputStreamReader(getClass()
2100: .getResourceAsStream("test_UnbalancedTrees.drl")));
2101: final Package pkg = builder.getPackage();
2102:
2103: final RuleBase ruleBase = getRuleBase();
2104: ruleBase.addPackage(pkg);
2105:
2106: final WorkingMemory wm = ruleBase.newStatefulSession();
2107:
2108: wm.insert(new Cheese("a", 10));
2109: wm.insert(new Cheese("b", 10));
2110: wm.insert(new Cheese("c", 10));
2111: wm.insert(new Cheese("d", 10));
2112: final Cheese e = new Cheese("e", 10);
2113: wm.insert(e);
2114:
2115: wm.fireAllRules();
2116:
2117: Assert.assertEquals(
2118: "Rule should have fired twice, seting the price to 30",
2119: 30, e.getPrice());
2120: // success
2121: }
2122:
2123: public void testImportConflict() throws Exception {
2124: final RuleBase ruleBase = getRuleBase();
2125: final PackageBuilder builder = new PackageBuilder();
2126: builder.addPackageFromDrl(new InputStreamReader(getClass()
2127: .getResourceAsStream("test_ImportConflict.drl")));
2128: final Package pkg = builder.getPackage();
2129: ruleBase.addPackage(pkg);
2130: }
2131:
2132: public void testPrimitiveArray() throws Exception {
2133: final PackageBuilder builder = new PackageBuilder();
2134: builder.addPackageFromDrl(new InputStreamReader(getClass()
2135: .getResourceAsStream("test_primitiveArray.drl")));
2136: final Package pkg = builder.getPackage();
2137:
2138: final RuleBase ruleBase = getRuleBase();
2139: ruleBase.addPackage(pkg);
2140: final WorkingMemory workingMemory = ruleBase
2141: .newStatefulSession();
2142: final List result = new ArrayList();
2143: workingMemory.setGlobal("result", result);
2144:
2145: final Primitives p1 = new Primitives();
2146: p1.setPrimitiveArrayAttribute(new int[] { 1, 2, 3 });
2147: p1.setArrayAttribute(new String[] { "a", "b" });
2148:
2149: workingMemory.insert(p1);
2150:
2151: workingMemory.fireAllRules();
2152: assertEquals(3, result.size());
2153: assertEquals(3, ((Integer) result.get(0)).intValue());
2154: assertEquals(2, ((Integer) result.get(1)).intValue());
2155: assertEquals(3, ((Integer) result.get(2)).intValue());
2156:
2157: }
2158:
2159: public void testEmptyIdentifier() throws Exception {
2160: final PackageBuilder builder = new PackageBuilder();
2161: builder.addPackageFromDrl(new InputStreamReader(getClass()
2162: .getResourceAsStream("test_emptyIdentifier.drl")));
2163: final Package pkg = builder.getPackage();
2164:
2165: final RuleBase ruleBase = getRuleBase();
2166: ruleBase.addPackage(pkg);
2167: final WorkingMemory workingMemory = ruleBase
2168: .newStatefulSession();
2169: final List result = new ArrayList();
2170: workingMemory.setGlobal("results", result);
2171:
2172: final Person person = new Person("bob");
2173: final Cheese cheese = new Cheese("brie", 10);
2174:
2175: workingMemory.insert(person);
2176: workingMemory.insert(cheese);
2177:
2178: workingMemory.fireAllRules();
2179: assertEquals(4, result.size());
2180: }
2181:
2182: public void testDuplicateVariableBinding() throws Exception {
2183: final PackageBuilder builder = new PackageBuilder();
2184: builder.addPackageFromDrl(new InputStreamReader(getClass()
2185: .getResourceAsStream(
2186: "test_duplicateVariableBinding.drl")));
2187: final Package pkg = builder.getPackage();
2188:
2189: final RuleBase ruleBase = getRuleBase();
2190: ruleBase.addPackage(pkg);
2191: final WorkingMemory workingMemory = ruleBase
2192: .newStatefulSession();
2193: final Map result = new HashMap();
2194: workingMemory.setGlobal("results", result);
2195:
2196: final Cheese stilton = new Cheese("stilton", 20);
2197: final Cheese brie = new Cheese("brie", 10);
2198:
2199: workingMemory.insert(stilton);
2200: workingMemory.insert(brie);
2201:
2202: workingMemory.fireAllRules();
2203: assertEquals(5, result.size());
2204: assertEquals(stilton.getPrice(), ((Integer) result.get(stilton
2205: .getType())).intValue());
2206: assertEquals(brie.getPrice(), ((Integer) result.get(brie
2207: .getType())).intValue());
2208:
2209: assertEquals(stilton.getPrice(),
2210: ((Integer) result.get(stilton)).intValue());
2211: assertEquals(brie.getPrice(), ((Integer) result.get(brie))
2212: .intValue());
2213:
2214: assertEquals(stilton.getPrice(), ((Integer) result.get("test3"
2215: + stilton.getType())).intValue());
2216:
2217: workingMemory.insert(new Person("bob", brie.getType()));
2218: workingMemory.fireAllRules();
2219:
2220: assertEquals(6, result.size());
2221: assertEquals(brie.getPrice(), ((Integer) result.get("test3"
2222: + brie.getType())).intValue());
2223: }
2224:
2225: public void testDuplicateVariableBindingError() throws Exception {
2226: final PackageBuilder builder = new PackageBuilder();
2227: builder.addPackageFromDrl(new InputStreamReader(getClass()
2228: .getResourceAsStream(
2229: "test_duplicateVariableBindingError.drl")));
2230: final Package pkg = builder.getPackage();
2231:
2232: assertFalse(pkg.isValid());
2233: System.out.println(pkg.getErrorSummary());
2234: assertEquals(6, pkg.getErrorSummary().split("\n").length);
2235: }
2236:
2237: public void testShadowProxyInHirarchies() throws Exception {
2238: final PackageBuilder builder = new PackageBuilder();
2239: builder.addPackageFromDrl(new InputStreamReader(
2240: getClass().getResourceAsStream(
2241: "test_ShadowProxyInHirarchies.drl")));
2242: final Package pkg = builder.getPackage();
2243:
2244: final RuleBase ruleBase = getRuleBase();
2245: ruleBase.addPackage(pkg);
2246: final WorkingMemory workingMemory = ruleBase
2247: .newStatefulSession();
2248:
2249: workingMemory.insert(new Child("gp"));
2250:
2251: workingMemory.fireAllRules();
2252: }
2253:
2254: public void testSelfReference() throws Exception {
2255: final PackageBuilder builder = new PackageBuilder();
2256: builder.addPackageFromDrl(new InputStreamReader(getClass()
2257: .getResourceAsStream("test_SelfReference.drl")));
2258: final Package pkg = builder.getPackage();
2259:
2260: final RuleBase ruleBase = getRuleBase();
2261: ruleBase.addPackage(pkg);
2262: final WorkingMemory workingMemory = ruleBase
2263: .newStatefulSession();
2264:
2265: final List results = new ArrayList();
2266: workingMemory.setGlobal("results", results);
2267:
2268: final Order order = new Order(10, "Bob");
2269: final OrderItem item1 = new OrderItem(order, 1);
2270: final OrderItem item2 = new OrderItem(order, 2);
2271: final OrderItem anotherItem1 = new OrderItem(null, 3);
2272: final OrderItem anotherItem2 = new OrderItem(null, 4);
2273: workingMemory.insert(order);
2274: workingMemory.insert(item1);
2275: workingMemory.insert(item2);
2276: workingMemory.insert(anotherItem1);
2277: workingMemory.insert(anotherItem2);
2278:
2279: workingMemory.fireAllRules();
2280:
2281: assertEquals(2, results.size());
2282: assertTrue(results.contains(item1));
2283: assertTrue(results.contains(item2));
2284: }
2285:
2286: public void testNumberComparisons() throws Exception {
2287: final PackageBuilder builder = new PackageBuilder();
2288: builder.addPackageFromDrl(new InputStreamReader(getClass()
2289: .getResourceAsStream("test_NumberComparisons.drl")));
2290: final Package pkg = builder.getPackage();
2291:
2292: final RuleBase ruleBase = getRuleBase();
2293: ruleBase.addPackage(pkg);
2294: final WorkingMemory workingMemory = ruleBase
2295: .newStatefulSession();
2296:
2297: final List list = new ArrayList();
2298: workingMemory.setGlobal("results", list);
2299:
2300: // asserting the sensor object
2301: final RandomNumber rn = new RandomNumber();
2302: rn.setValue(10);
2303: workingMemory.insert(rn);
2304:
2305: final Guess guess = new Guess();
2306: guess.setValue(new Integer(5));
2307:
2308: final FactHandle handle = workingMemory.insert(guess);
2309:
2310: workingMemory.fireAllRules();
2311:
2312: // HIGHER
2313: assertEquals(1, list.size());
2314: assertEquals("HIGHER", list.get(0));
2315:
2316: guess.setValue(new Integer(15));
2317: workingMemory.update(handle, guess);
2318:
2319: workingMemory.fireAllRules();
2320:
2321: // LOWER
2322: assertEquals(2, list.size());
2323: assertEquals("LOWER", list.get(1));
2324:
2325: guess.setValue(new Integer(10));
2326: workingMemory.update(handle, guess);
2327:
2328: workingMemory.fireAllRules();
2329:
2330: // CORRECT
2331: assertEquals(3, list.size());
2332: assertEquals("CORRECT", list.get(2));
2333:
2334: }
2335:
2336: public void testSkipModify() throws Exception {
2337: final PackageBuilder builder = new PackageBuilder();
2338: builder.addPackageFromDrl(new InputStreamReader(getClass()
2339: .getResourceAsStream("test_skipModify.drl")));
2340: final Package pkg = builder.getPackage();
2341:
2342: final RuleBase ruleBase = getRuleBase();
2343: ruleBase.addPackage(pkg);
2344: final WorkingMemory workingMemory = ruleBase
2345: .newStatefulSession();
2346:
2347: final List results = new ArrayList();
2348: workingMemory.setGlobal("results", results);
2349:
2350: final Cheese cheese = new Cheese("brie", 10);
2351: final FactHandle handle = workingMemory.insert(cheese);
2352:
2353: final Person bob = new Person("bob", "stilton");
2354: workingMemory.insert(bob);
2355:
2356: cheese.setType("stilton");
2357: workingMemory.update(handle, cheese);
2358: workingMemory.fireAllRules();
2359: assertEquals(2, results.size());
2360: }
2361:
2362: public void testEventModel() throws Exception {
2363: final PackageBuilder builder = new PackageBuilder();
2364: builder.addPackageFromDrl(new InputStreamReader(getClass()
2365: .getResourceAsStream("test_EventModel.drl")));
2366: final Package pkg = builder.getPackage();
2367:
2368: final RuleBase ruleBase = getRuleBase();
2369: ruleBase.addPackage(pkg);
2370: final WorkingMemory wm = ruleBase.newStatefulSession();
2371:
2372: final List agendaList = new ArrayList();
2373: final AgendaEventListener agendaEventListener = new AgendaEventListener() {
2374:
2375: public void activationCancelled(
2376: ActivationCancelledEvent event,
2377: WorkingMemory workingMemory) {
2378: agendaList.add(event);
2379:
2380: }
2381:
2382: public void activationCreated(ActivationCreatedEvent event,
2383: WorkingMemory workingMemory) {
2384: agendaList.add(event);
2385: }
2386:
2387: public void afterActivationFired(
2388: AfterActivationFiredEvent event,
2389: WorkingMemory workingMemory) {
2390: agendaList.add(event);
2391: }
2392:
2393: public void agendaGroupPopped(AgendaGroupPoppedEvent event,
2394: WorkingMemory workingMemory) {
2395: agendaList.add(event);
2396: }
2397:
2398: public void agendaGroupPushed(AgendaGroupPushedEvent event,
2399: WorkingMemory workingMemory) {
2400: agendaList.add(event);
2401: }
2402:
2403: public void beforeActivationFired(
2404: BeforeActivationFiredEvent event,
2405: WorkingMemory workingMemory) {
2406: agendaList.add(event);
2407: }
2408:
2409: };
2410:
2411: final List wmList = new ArrayList();
2412: final WorkingMemoryEventListener workingMemoryListener = new WorkingMemoryEventListener() {
2413:
2414: public void objectInserted(ObjectInsertedEvent event) {
2415: wmList.add(event);
2416: }
2417:
2418: public void objectUpdated(ObjectUpdatedEvent event) {
2419: wmList.add(event);
2420: }
2421:
2422: public void objectRetracted(ObjectRetractedEvent event) {
2423: wmList.add(event);
2424: }
2425:
2426: };
2427:
2428: wm.addEventListener(workingMemoryListener);
2429:
2430: final Cheese stilton = new Cheese("stilton", 15);
2431: final Cheese cheddar = new Cheese("cheddar", 17);
2432:
2433: final FactHandle stiltonHandle = wm.insert(stilton);
2434:
2435: final ObjectInsertedEvent oae = (ObjectInsertedEvent) wmList
2436: .get(0);
2437: assertSame(stiltonHandle, oae.getFactHandle());
2438:
2439: wm.update(stiltonHandle, stilton);
2440: final ObjectUpdatedEvent ome = (ObjectUpdatedEvent) wmList
2441: .get(1);
2442: assertSame(stiltonHandle, ome.getFactHandle());
2443:
2444: wm.retract(stiltonHandle);
2445: final ObjectRetractedEvent ore = (ObjectRetractedEvent) wmList
2446: .get(2);
2447: assertSame(stiltonHandle, ore.getFactHandle());
2448:
2449: wm.insert(cheddar);
2450: }
2451:
2452: public void testImplicitDeclarations() throws Exception {
2453: final PackageBuilder builder = new PackageBuilder();
2454: builder.addPackageFromDrl(new InputStreamReader(getClass()
2455: .getResourceAsStream("test_implicitDeclarations.drl")));
2456: final Package pkg = builder.getPackage();
2457:
2458: final RuleBase ruleBase = getRuleBase();
2459: ruleBase.addPackage(pkg);
2460: final WorkingMemory workingMemory = ruleBase
2461: .newStatefulSession();
2462:
2463: final List results = new ArrayList();
2464: workingMemory.setGlobal("results", results);
2465: workingMemory.setGlobal("factor", new Double(1.2));
2466:
2467: final Cheese cheese = new Cheese("stilton", 10);
2468: workingMemory.insert(cheese);
2469:
2470: workingMemory.fireAllRules();
2471: assertEquals(1, results.size());
2472: }
2473:
2474: public void testCastingInsideEvals() throws Exception {
2475: final PackageBuilder builder = new PackageBuilder();
2476: builder.addPackageFromDrl(new InputStreamReader(getClass()
2477: .getResourceAsStream("test_castsInsideEval.drl")));
2478: final Package pkg = builder.getPackage();
2479:
2480: final RuleBase ruleBase = getRuleBase();
2481: ruleBase.addPackage(pkg);
2482: final WorkingMemory workingMemory = ruleBase
2483: .newStatefulSession();
2484:
2485: workingMemory.setGlobal("value", new Integer(20));
2486:
2487: workingMemory.fireAllRules();
2488: }
2489:
2490: public void testMemberOfAndNotMemberOf() throws Exception {
2491: final PackageBuilder builder = new PackageBuilder();
2492: builder.addPackageFromDrl(new InputStreamReader(getClass()
2493: .getResourceAsStream("test_memberOf.drl")));
2494: final Package pkg = builder.getPackage();
2495:
2496: final RuleBase ruleBase = getRuleBase();
2497: ruleBase.addPackage(pkg);
2498: final WorkingMemory workingMemory = ruleBase
2499: .newStatefulSession();
2500:
2501: final List list = new ArrayList();
2502: workingMemory.setGlobal("list", list);
2503:
2504: final Cheese stilton = new Cheese("stilton", 12);
2505: final Cheese muzzarela = new Cheese("muzzarela", 10);
2506: final Cheese brie = new Cheese("brie", 15);
2507: workingMemory.insert(stilton);
2508: workingMemory.insert(muzzarela);
2509:
2510: final Cheesery cheesery = new Cheesery();
2511: cheesery.getCheeses().add(stilton.getType());
2512: cheesery.getCheeses().add(brie.getType());
2513: workingMemory.insert(cheesery);
2514:
2515: workingMemory.fireAllRules();
2516:
2517: assertEquals(2, list.size());
2518:
2519: assertEquals(stilton, list.get(0));
2520: assertEquals(muzzarela, list.get(1));
2521: }
2522:
2523: public void testContainsInArray() throws Exception {
2524: final PackageBuilder builder = new PackageBuilder();
2525: builder.addPackageFromDrl(new InputStreamReader(getClass()
2526: .getResourceAsStream("test_contains_in_array.drl")));
2527: final Package pkg = builder.getPackage();
2528:
2529: final RuleBase ruleBase = getRuleBase();
2530: ruleBase.addPackage(pkg);
2531: final WorkingMemory workingMemory = ruleBase
2532: .newStatefulSession();
2533:
2534: final List list = new ArrayList();
2535: workingMemory.setGlobal("list", list);
2536:
2537: final Primitives p = new Primitives();
2538: p.setStringArray(new String[] { "test1", "test3" });
2539: workingMemory.insert(p);
2540:
2541: workingMemory.fireAllRules();
2542:
2543: assertEquals(2, list.size());
2544:
2545: assertEquals("ok1", list.get(0));
2546: assertEquals("ok2", list.get(1));
2547: }
2548:
2549: public void testCollectNodeSharing() throws Exception {
2550: final PackageBuilder builder = new PackageBuilder();
2551: builder.addPackageFromDrl(new InputStreamReader(getClass()
2552: .getResourceAsStream("test_collectNodeSharing.drl")));
2553: final Package pkg = builder.getPackage();
2554:
2555: final RuleBase ruleBase = getRuleBase();
2556: ruleBase.addPackage(pkg);
2557: final WorkingMemory workingMemory = ruleBase
2558: .newStatefulSession();
2559:
2560: final List list = new ArrayList();
2561: workingMemory.setGlobal("results", list);
2562:
2563: workingMemory.insert(new Cheese("stilton", 10));
2564: workingMemory.insert(new Cheese("brie", 15));
2565:
2566: workingMemory.fireAllRules();
2567:
2568: assertEquals(1, list.size());
2569:
2570: assertEquals(2, ((List) list.get(0)).size());
2571: }
2572:
2573: public void testNodeSharingNotExists() throws Exception {
2574: final PackageBuilder builder = new PackageBuilder();
2575: builder.addPackageFromDrl(new InputStreamReader(getClass()
2576: .getResourceAsStream("test_nodeSharingNotExists.drl")));
2577: final Package pkg = builder.getPackage();
2578:
2579: final RuleBase ruleBase = getRuleBase();
2580: ruleBase.addPackage(pkg);
2581: final WorkingMemory workingMemory = ruleBase
2582: .newStatefulSession();
2583:
2584: final List list = new ArrayList();
2585: workingMemory.setGlobal("results", list);
2586:
2587: workingMemory.fireAllRules();
2588:
2589: assertEquals(1, list.size());
2590:
2591: assertEquals("rule1", list.get(0));
2592:
2593: workingMemory.insert(new Cheese("stilton", 10));
2594: workingMemory.fireAllRules();
2595:
2596: assertEquals(2, list.size());
2597:
2598: assertEquals("rule2", list.get(1));
2599:
2600: }
2601:
2602: public void testNullBinding() throws Exception {
2603: final PackageBuilder builder = new PackageBuilder();
2604: builder.addPackageFromDrl(new InputStreamReader(getClass()
2605: .getResourceAsStream("test_nullBindings.drl")));
2606: final Package pkg = builder.getPackage();
2607:
2608: final RuleBase ruleBase = getRuleBase();
2609: ruleBase.addPackage(pkg);
2610: final WorkingMemory workingMemory = ruleBase
2611: .newStatefulSession();
2612:
2613: final List list = new ArrayList();
2614: workingMemory.setGlobal("results", list);
2615:
2616: workingMemory.insert(new Person("bob"));
2617: workingMemory.insert(new Person(null));
2618:
2619: workingMemory.fireAllRules();
2620:
2621: assertEquals(1, list.size());
2622:
2623: assertEquals("OK", list.get(0));
2624:
2625: }
2626:
2627: public void testModifyRetractWithFunction() throws Exception {
2628: final PackageBuilder builder = new PackageBuilder();
2629: builder.addPackageFromDrl(new InputStreamReader(getClass()
2630: .getResourceAsStream(
2631: "test_RetractModifyWithFunction.drl")));
2632: final Package pkg = builder.getPackage();
2633:
2634: final RuleBase ruleBase = getRuleBase();
2635: ruleBase.addPackage(pkg);
2636: final AbstractWorkingMemory workingMemory = (AbstractWorkingMemory) ruleBase
2637: .newStatefulSession();
2638:
2639: final Cheese stilton = new Cheese("stilton", 7);
2640: final Cheese muzzarella = new Cheese("muzzarella", 9);
2641: final int sum = stilton.getPrice() + muzzarella.getPrice();
2642: final FactHandle stiltonHandle = workingMemory.insert(stilton);
2643: final FactHandle muzzarellaHandle = workingMemory
2644: .insert(muzzarella);
2645:
2646: workingMemory.fireAllRules();
2647:
2648: assertEquals(sum, stilton.getPrice());
2649: assertEquals(1, workingMemory.getFactHandleMap().size());
2650: assertNotNull(workingMemory.getObject(stiltonHandle));
2651: assertNotNull(workingMemory.getFactHandle(stilton));
2652:
2653: assertNull(workingMemory.getObject(muzzarellaHandle));
2654: assertNull(workingMemory.getFactHandle(muzzarella));
2655:
2656: }
2657:
2658: public void testConstraintConnectors() throws Exception {
2659: final PackageBuilder builder = new PackageBuilder();
2660: builder.addPackageFromDrl(new InputStreamReader(getClass()
2661: .getResourceAsStream("test_ConstraintConnectors.drl")));
2662: final Package pkg = builder.getPackage();
2663:
2664: final RuleBase ruleBase = getRuleBase();
2665: ruleBase.addPackage(pkg);
2666: final WorkingMemory workingMemory = ruleBase
2667: .newStatefulSession();
2668:
2669: final List results = new ArrayList();
2670: workingMemory.setGlobal("results", results);
2671:
2672: final Person youngChili1 = new Person("young chili1");
2673: youngChili1.setAge(12);
2674: youngChili1.setHair("blue");
2675: final Person youngChili2 = new Person("young chili2");
2676: youngChili2.setAge(25);
2677: youngChili2.setHair("purple");
2678:
2679: final Person chili1 = new Person("chili1");
2680: chili1.setAge(35);
2681: chili1.setHair("red");
2682:
2683: final Person chili2 = new Person("chili2");
2684: chili2.setAge(38);
2685: chili2.setHair("indigigo");
2686:
2687: final Person oldChili1 = new Person("old chili2");
2688: oldChili1.setAge(45);
2689: oldChili1.setHair("green");
2690:
2691: final Person oldChili2 = new Person("old chili2");
2692: oldChili2.setAge(48);
2693: oldChili2.setHair("blue");
2694:
2695: final Person veryold = new Person("very old");
2696: veryold.setAge(99);
2697: veryold.setHair("gray");
2698:
2699: workingMemory.insert(youngChili1);
2700: workingMemory.insert(youngChili2);
2701: workingMemory.insert(chili1);
2702: workingMemory.insert(chili2);
2703: workingMemory.insert(oldChili1);
2704: workingMemory.insert(oldChili2);
2705: workingMemory.insert(veryold);
2706:
2707: workingMemory.fireAllRules();
2708:
2709: assertEquals(4, results.size());
2710: assertEquals(chili1, results.get(0));
2711: assertEquals(oldChili1, results.get(1));
2712: assertEquals(youngChili1, results.get(2));
2713: assertEquals(veryold, results.get(3));
2714:
2715: }
2716:
2717: public void testMatchesNotMatchesCheese() throws Exception {
2718: final PackageBuilder builder = new PackageBuilder();
2719: builder.addPackageFromDrl(new InputStreamReader(getClass()
2720: .getResourceAsStream("test_MatchesNotMatches.drl")));
2721: final Package pkg = builder.getPackage();
2722:
2723: final RuleBase ruleBase = getRuleBase();
2724: ruleBase.addPackage(pkg);
2725: final WorkingMemory workingMemory = ruleBase
2726: .newStatefulSession();
2727:
2728: final List list = new ArrayList();
2729: workingMemory.setGlobal("list", list);
2730:
2731: final Cheese stilton = new Cheese("stilton", 12);
2732: final Cheese stilton2 = new Cheese("stilton2", 12);
2733: final Cheese brie = new Cheese("brie", 10);
2734: final Cheese brie2 = new Cheese("brie2", 10);
2735: final Cheese muzzarella = new Cheese("muzzarella", 10);
2736: final Cheese muzzarella2 = new Cheese("muzzarella2", 10);
2737: workingMemory.insert(stilton);
2738: workingMemory.insert(stilton2);
2739: workingMemory.insert(brie);
2740: workingMemory.insert(brie2);
2741: workingMemory.insert(muzzarella);
2742: workingMemory.insert(muzzarella2);
2743:
2744: workingMemory.fireAllRules();
2745:
2746: assertEquals(2, list.size());
2747:
2748: assertEquals(stilton, list.get(0));
2749: assertEquals(brie, list.get(1));
2750: }
2751:
2752: public void testAutomaticBindings() throws Exception {
2753: final PackageBuilder builder = new PackageBuilder();
2754: builder.addPackageFromDrl(new InputStreamReader(getClass()
2755: .getResourceAsStream("test_AutoBindings.drl")));
2756: final Package pkg = builder.getPackage();
2757:
2758: final RuleBase ruleBase = getRuleBase();
2759: ruleBase.addPackage(pkg);
2760: final WorkingMemory workingMemory = ruleBase
2761: .newStatefulSession();
2762:
2763: final List list = new ArrayList();
2764: workingMemory.setGlobal("results", list);
2765:
2766: final Person bob = new Person("bob", "stilton");
2767: final Cheese stilton = new Cheese("stilton", 12);
2768: workingMemory.insert(bob);
2769: workingMemory.insert(stilton);
2770:
2771: workingMemory.fireAllRules();
2772:
2773: assertEquals(1, list.size());
2774:
2775: assertEquals(bob, list.get(0));
2776: }
2777:
2778: public void testAutomaticBindingsErrors() throws Exception {
2779: final PackageBuilder builder = new PackageBuilder();
2780: builder.addPackageFromDrl(new InputStreamReader(getClass()
2781: .getResourceAsStream("test_AutoBindingsErrors.drl")));
2782: final Package pkg = builder.getPackage();
2783:
2784: assertNotNull(pkg.getErrorSummary());
2785: }
2786:
2787: public void testQualifiedFieldReference() throws Exception {
2788: final PackageBuilder builder = new PackageBuilder();
2789: builder.addPackageFromDrl(new InputStreamReader(
2790: getClass().getResourceAsStream(
2791: "test_QualifiedFieldReference.drl")));
2792: final Package pkg = builder.getPackage();
2793:
2794: final RuleBase ruleBase = getRuleBase();
2795: ruleBase.addPackage(pkg);
2796: final WorkingMemory workingMemory = ruleBase
2797: .newStatefulSession();
2798:
2799: final List list = new ArrayList();
2800: workingMemory.setGlobal("results", list);
2801:
2802: final Person bob = new Person("bob", "stilton");
2803: final Cheese stilton = new Cheese("stilton", 12);
2804: workingMemory.insert(bob);
2805: workingMemory.insert(stilton);
2806:
2807: workingMemory.fireAllRules();
2808:
2809: assertEquals(1, list.size());
2810:
2811: assertEquals(bob, list.get(0));
2812: }
2813:
2814: public void testEvalRewrite() throws Exception {
2815: final PackageBuilder builder = new PackageBuilder();
2816: builder.addPackageFromDrl(new InputStreamReader(getClass()
2817: .getResourceAsStream("test_EvalRewrite.drl")));
2818: final Package pkg = builder.getPackage();
2819:
2820: final RuleBase ruleBase = getRuleBase();
2821: ruleBase.addPackage(pkg);
2822: final WorkingMemory workingMemory = ruleBase
2823: .newStatefulSession();
2824:
2825: final List list = new ArrayList();
2826: workingMemory.setGlobal("results", list);
2827:
2828: final Order order1 = new Order(10, "Bob");
2829: final OrderItem item11 = new OrderItem(order1, 1);
2830: final OrderItem item12 = new OrderItem(order1, 2);
2831: order1.addItem(item11);
2832: order1.addItem(item12);
2833: final Order order2 = new Order(11, "Bob");
2834: final OrderItem item21 = new OrderItem(order2, 1);
2835: final OrderItem item22 = new OrderItem(order2, 2);
2836: order2.addItem(item21);
2837: order2.addItem(item22);
2838: final Order order3 = new Order(12, "Bob");
2839: final OrderItem item31 = new OrderItem(order3, 1);
2840: final OrderItem item32 = new OrderItem(order3, 2);
2841: order3.addItem(item31);
2842: order3.addItem(item32);
2843: final Order order4 = new Order(13, "Bob");
2844: final OrderItem item41 = new OrderItem(order4, 1);
2845: final OrderItem item42 = new OrderItem(order4, 2);
2846: order4.addItem(item41);
2847: order4.addItem(item42);
2848: workingMemory.insert(order1);
2849: workingMemory.insert(item11);
2850: workingMemory.insert(item12);
2851: workingMemory.insert(order2);
2852: workingMemory.insert(item21);
2853: workingMemory.insert(item22);
2854: workingMemory.insert(order3);
2855: workingMemory.insert(item31);
2856: workingMemory.insert(item32);
2857: workingMemory.insert(order4);
2858: workingMemory.insert(item41);
2859: workingMemory.insert(item42);
2860:
2861: workingMemory.fireAllRules();
2862:
2863: assertEquals(5, list.size());
2864: assertTrue(list.contains(item11));
2865: assertTrue(list.contains(item12));
2866: assertTrue(list.contains(item22));
2867: assertTrue(list.contains(order3));
2868: assertTrue(list.contains(order4));
2869:
2870: }
2871:
2872: public void testMapAccess() throws Exception {
2873: final PackageBuilder builder = new PackageBuilder();
2874: builder.addPackageFromDrl(new InputStreamReader(getClass()
2875: .getResourceAsStream("test_MapAccess.drl")));
2876: final Package pkg = builder.getPackage();
2877:
2878: final RuleBase ruleBase = getRuleBase();
2879: ruleBase.addPackage(pkg);
2880: final WorkingMemory workingMemory = ruleBase
2881: .newStatefulSession();
2882:
2883: final List list = new ArrayList();
2884: workingMemory.setGlobal("results", list);
2885:
2886: Map map = new HashMap();
2887: map.put("name", "Edson");
2888: map.put("surname", "Tirelli");
2889: map.put("age", "28");
2890:
2891: workingMemory.insert(map);
2892:
2893: workingMemory.fireAllRules();
2894:
2895: assertEquals(1, list.size());
2896: assertTrue(list.contains(map));
2897:
2898: }
2899:
2900: public void testHalt() throws Exception {
2901: final PackageBuilder builder = new PackageBuilder();
2902: builder.addPackageFromDrl(new InputStreamReader(getClass()
2903: .getResourceAsStream("test_halt.drl")));
2904: final Package pkg = builder.getPackage();
2905:
2906: final RuleBase ruleBase = getRuleBase();
2907: ruleBase.addPackage(pkg);
2908: final WorkingMemory workingMemory = ruleBase
2909: .newStatefulSession();
2910:
2911: final List results = new ArrayList();
2912: workingMemory.setGlobal("results", results);
2913:
2914: workingMemory.insert(new Integer(0));
2915: workingMemory.fireAllRules();
2916:
2917: assertEquals(10, results.size());
2918: for (int i = 0; i < 10; i++) {
2919: assertEquals(new Integer(i), results.get(i));
2920: }
2921: }
2922:
2923: public void testFireLimit() throws Exception {
2924: final PackageBuilder builder = new PackageBuilder();
2925: builder.addPackageFromDrl(new InputStreamReader(getClass()
2926: .getResourceAsStream("test_fireLimit.drl")));
2927: final Package pkg = builder.getPackage();
2928:
2929: final RuleBase ruleBase = getRuleBase();
2930: ruleBase.addPackage(pkg);
2931: final WorkingMemory workingMemory = ruleBase
2932: .newStatefulSession();
2933:
2934: final List results = new ArrayList();
2935: workingMemory.setGlobal("results", results);
2936:
2937: workingMemory.insert(new Integer(0));
2938: workingMemory.fireAllRules();
2939:
2940: assertEquals(20, results.size());
2941: for (int i = 0; i < 20; i++) {
2942: assertEquals(new Integer(i), results.get(i));
2943: }
2944: results.clear();
2945:
2946: workingMemory.insert(new Integer(0));
2947: workingMemory.fireAllRules(10);
2948:
2949: assertEquals(10, results.size());
2950: for (int i = 0; i < 10; i++) {
2951: assertEquals(new Integer(i), results.get(i));
2952: }
2953: results.clear();
2954:
2955: workingMemory.insert(new Integer(0));
2956: workingMemory.fireAllRules(-1);
2957:
2958: assertEquals(20, results.size());
2959: for (int i = 0; i < 20; i++) {
2960: assertEquals(new Integer(i), results.get(i));
2961: }
2962: results.clear();
2963:
2964: }
2965:
2966: public void testGlobals2() throws Exception {
2967:
2968: final PackageBuilder builder = new PackageBuilder();
2969: builder.addPackageFromDrl(new InputStreamReader(getClass()
2970: .getResourceAsStream("test_globalsAsConstraints.drl")));
2971: final Package pkg = builder.getPackage();
2972:
2973: final RuleBase ruleBase = getRuleBase();
2974: ruleBase.addPackage(pkg);
2975: final WorkingMemory workingMemory = ruleBase
2976: .newStatefulSession();
2977:
2978: final List results = new ArrayList();
2979: workingMemory.setGlobal("results", results);
2980:
2981: final List cheeseTypes = new ArrayList();
2982: workingMemory.setGlobal("cheeseTypes", cheeseTypes);
2983: cheeseTypes.add("stilton");
2984: cheeseTypes.add("muzzarela");
2985:
2986: final Cheese stilton = new Cheese("stilton", 5);
2987: workingMemory.insert(stilton);
2988:
2989: workingMemory.fireAllRules();
2990:
2991: assertEquals(1, results.size());
2992: assertEquals("memberOf", results.get(0));
2993:
2994: final Cheese brie = new Cheese("brie", 5);
2995: workingMemory.insert(brie);
2996:
2997: workingMemory.fireAllRules();
2998:
2999: assertEquals(2, results.size());
3000: assertEquals("not memberOf", results.get(1));
3001: }
3002:
3003: public void testEqualitySupport() throws Exception {
3004:
3005: final PackageBuilder builder = new PackageBuilder();
3006: builder.addPackageFromDrl(new InputStreamReader(getClass()
3007: .getResourceAsStream("test_equalitySupport.drl")));
3008: final Package pkg = builder.getPackage();
3009:
3010: RuleBaseConfiguration conf = new RuleBaseConfiguration();
3011: conf
3012: .setAssertBehaviour(RuleBaseConfiguration.AssertBehaviour.EQUALITY);
3013: final RuleBase ruleBase = getRuleBase(conf);
3014: ruleBase.addPackage(pkg);
3015: final WorkingMemory workingMemory = ruleBase
3016: .newStatefulSession();
3017:
3018: final List results = new ArrayList();
3019: workingMemory.setGlobal("results", results);
3020:
3021: PersonWithEquals person = new PersonWithEquals("bob", 30);
3022:
3023: workingMemory.insert(person);
3024:
3025: workingMemory.fireAllRules();
3026:
3027: assertEquals(1, results.size());
3028: assertEquals("mark", results.get(0));
3029:
3030: }
3031:
3032: public void testCharComparisons() throws Exception {
3033:
3034: final PackageBuilder builder = new PackageBuilder();
3035: builder.addPackageFromDrl(new InputStreamReader(getClass()
3036: .getResourceAsStream("test_charComparisons.drl")));
3037: final Package pkg = builder.getPackage();
3038:
3039: final RuleBase ruleBase = getRuleBase();
3040: ruleBase.addPackage(pkg);
3041: final WorkingMemory workingMemory = ruleBase
3042: .newStatefulSession();
3043:
3044: final List results = new ArrayList();
3045: workingMemory.setGlobal("results", results);
3046:
3047: Primitives p1 = new Primitives();
3048: p1.setCharPrimitive('a');
3049: p1.setStringAttribute("b");
3050: Primitives p2 = new Primitives();
3051: p2.setCharPrimitive('b');
3052: p2.setStringAttribute("a");
3053:
3054: workingMemory.insert(p1);
3055: workingMemory.insert(p2);
3056:
3057: workingMemory.fireAllRules();
3058:
3059: assertEquals(3, results.size());
3060: assertEquals("1", results.get(0));
3061: assertEquals("2", results.get(1));
3062: assertEquals("3", results.get(2));
3063:
3064: }
3065:
3066: public void testAlphaNodeSharing() throws Exception {
3067:
3068: final PackageBuilder builder = new PackageBuilder();
3069: builder.addPackageFromDrl(new InputStreamReader(getClass()
3070: .getResourceAsStream("test_alphaNodeSharing.drl")));
3071: final Package pkg = builder.getPackage();
3072:
3073: final RuleBaseConfiguration conf = new RuleBaseConfiguration();
3074: conf.setShareAlphaNodes(false);
3075: final RuleBase ruleBase = getRuleBase(conf);
3076: ruleBase.addPackage(pkg);
3077: final WorkingMemory workingMemory = ruleBase
3078: .newStatefulSession();
3079:
3080: final List results = new ArrayList();
3081: workingMemory.setGlobal("results", results);
3082:
3083: Person p1 = new Person("bob", 5);
3084: workingMemory.insert(p1);
3085:
3086: workingMemory.fireAllRules();
3087:
3088: assertEquals(2, results.size());
3089: assertEquals("1", results.get(0));
3090: assertEquals("2", results.get(1));
3091:
3092: }
3093:
3094: public void testFunctionCallingFunction() throws Exception {
3095: final PackageBuilder builder = new PackageBuilder();
3096: builder.addPackageFromDrl(new InputStreamReader(
3097: getClass().getResourceAsStream(
3098: "test_functionCallingFunction.drl")));
3099: final Package pkg = builder.getPackage();
3100:
3101: final RuleBase ruleBase = getRuleBase();
3102: ruleBase.addPackage(pkg);
3103: final WorkingMemory workingMemory = ruleBase
3104: .newStatefulSession();
3105:
3106: final List list = new ArrayList();
3107: workingMemory.setGlobal("results", list);
3108:
3109: workingMemory.fireAllRules();
3110:
3111: assertEquals(1, list.size());
3112: }
3113:
3114: public void testSelfReference2() throws Exception {
3115: final PackageBuilder builder = new PackageBuilder();
3116: builder.addPackageFromDrl(new InputStreamReader(getClass()
3117: .getResourceAsStream("test_SelfReference2.drl")));
3118: final Package pkg = builder.getPackage();
3119:
3120: final RuleBase ruleBase = getRuleBase();
3121: ruleBase.addPackage(pkg);
3122: final WorkingMemory workingMemory = ruleBase
3123: .newStatefulSession();
3124:
3125: final List results = new ArrayList();
3126: workingMemory.setGlobal("results", results);
3127:
3128: workingMemory.insert(new Cheese());
3129:
3130: workingMemory.fireAllRules();
3131:
3132: assertEquals(0, results.size());
3133: }
3134:
3135: public void testMergingDifferentPackages() throws Exception {
3136: // using the same builder
3137: try {
3138: final PackageBuilder builder = new PackageBuilder();
3139: builder.addPackageFromDrl(new InputStreamReader(getClass()
3140: .getResourceAsStream("test_RuleNameClashes1.drl")));
3141: builder.addPackageFromDrl(new InputStreamReader(getClass()
3142: .getResourceAsStream("test_RuleNameClashes2.drl")));
3143: fail("Can't merge packages with different names ");
3144: } catch (PackageMergeException e) {
3145: // success
3146: } catch (RuntimeException e) {
3147: e.printStackTrace();
3148: fail("unexpected exception: " + e.getMessage());
3149: }
3150: }
3151:
3152: public void testMergingDifferentPackages2() throws Exception {
3153: // using different builders
3154: try {
3155: final PackageBuilder builder1 = new PackageBuilder();
3156: builder1.addPackageFromDrl(new InputStreamReader(getClass()
3157: .getResourceAsStream("test_RuleNameClashes1.drl")));
3158: final Package pkg1 = builder1.getPackage();
3159:
3160: assertEquals(1, pkg1.getRules().length);
3161:
3162: final PackageBuilder builder2 = new PackageBuilder();
3163: builder2.addPackageFromDrl(new InputStreamReader(getClass()
3164: .getResourceAsStream("test_RuleNameClashes2.drl")));
3165: final Package pkg2 = builder2.getPackage();
3166:
3167: assertEquals(1, pkg2.getRules().length);
3168:
3169: final RuleBase ruleBase = getRuleBase();
3170: ruleBase.addPackage(pkg1);
3171: ruleBase.addPackage(pkg2);
3172: final WorkingMemory workingMemory = ruleBase
3173: .newStatefulSession();
3174:
3175: final List results = new ArrayList();
3176: workingMemory.setGlobal("results", results);
3177:
3178: workingMemory.insert(new Cheese("stilton", 10));
3179: workingMemory.insert(new Cheese("brie", 5));
3180:
3181: workingMemory.fireAllRules();
3182:
3183: assertEquals(results.toString(), 2, results.size());
3184: assertTrue(results.contains("p1.r1"));
3185: assertTrue(results.contains("p2.r1"));
3186:
3187: } catch (PackageMergeException e) {
3188: fail("Should not raise exception when merging different packages into the same rulebase: "
3189: + e.getMessage());
3190: } catch (Exception e) {
3191: e.printStackTrace();
3192: fail("unexpected exception: " + e.getMessage());
3193: }
3194: }
3195:
3196: public void testRuleReplacement() throws Exception {
3197: // test rule replacement
3198: try {
3199: final PackageBuilder builder1 = new PackageBuilder();
3200: builder1.addPackageFromDrl(new InputStreamReader(getClass()
3201: .getResourceAsStream("test_RuleNameClashes1.drl")));
3202: builder1.addPackageFromDrl(new InputStreamReader(getClass()
3203: .getResourceAsStream("test_RuleNameClashes3.drl")));
3204: final Package pkg1 = builder1.getPackage();
3205:
3206: assertEquals(1, pkg1.getRules().length);
3207:
3208: final RuleBase ruleBase = getRuleBase();
3209: ruleBase.addPackage(pkg1);
3210: final WorkingMemory workingMemory = ruleBase
3211: .newStatefulSession();
3212:
3213: final List results = new ArrayList();
3214: workingMemory.setGlobal("results", results);
3215:
3216: workingMemory.insert(new Cheese("stilton", 10));
3217: workingMemory.insert(new Cheese("brie", 5));
3218:
3219: workingMemory.fireAllRules();
3220:
3221: assertEquals(results.toString(), 0, results.size());
3222:
3223: workingMemory.insert(new Cheese("muzzarella", 7));
3224:
3225: workingMemory.fireAllRules();
3226:
3227: assertEquals(results.toString(), 1, results.size());
3228: assertTrue(results.contains("p1.r3"));
3229:
3230: } catch (PackageMergeException e) {
3231: fail("Should not raise exception when merging different packages into the same rulebase: "
3232: + e.getMessage());
3233: } catch (Exception e) {
3234: e.printStackTrace();
3235: fail("unexpected exception: " + e.getMessage());
3236: }
3237: }
3238:
3239: public void testOutOfMemory() throws Exception {
3240: final PackageBuilder builder = new PackageBuilder();
3241: builder.addPackageFromDrl(new InputStreamReader(getClass()
3242: .getResourceAsStream("test_OutOfMemory.drl")));
3243: final Package pkg = builder.getPackage();
3244:
3245: final RuleBase ruleBase = getRuleBase();
3246: ruleBase.addPackage(pkg);
3247: final WorkingMemory workingMemory = ruleBase
3248: .newStatefulSession();
3249:
3250: workingMemory.insert(new Cheese("stilton", 1));
3251:
3252: workingMemory.fireAllRules(3000000);
3253:
3254: // just for profiling
3255: //Thread.currentThread().wait();
3256: }
3257:
3258: public void testBindingsOnConnectiveExpressions() throws Exception {
3259: final PackageBuilder builder = new PackageBuilder();
3260: builder.addPackageFromDrl(new InputStreamReader(getClass()
3261: .getResourceAsStream("test_bindings.drl")));
3262: final Package pkg = builder.getPackage();
3263:
3264: final RuleBase ruleBase = getRuleBase();
3265: ruleBase.addPackage(pkg);
3266: final WorkingMemory workingMemory = ruleBase
3267: .newStatefulSession();
3268:
3269: final List results = new ArrayList();
3270: workingMemory.setGlobal("results", results);
3271:
3272: workingMemory.insert(new Cheese("stilton", 15));
3273:
3274: workingMemory.fireAllRules();
3275:
3276: assertEquals(2, results.size());
3277: assertEquals("stilton", results.get(0));
3278: assertEquals(new Integer(15), results.get(1));
3279: }
3280:
3281: public void testMultipleFroms() throws Exception {
3282: final PackageBuilder builder = new PackageBuilder();
3283: builder.addPackageFromDrl(new InputStreamReader(getClass()
3284: .getResourceAsStream("test_multipleFroms.drl")));
3285: final Package pkg = builder.getPackage();
3286:
3287: final RuleBase ruleBase = getRuleBase();
3288: ruleBase.addPackage(pkg);
3289: final WorkingMemory workingMemory = ruleBase
3290: .newStatefulSession();
3291:
3292: final List results = new ArrayList();
3293: workingMemory.setGlobal("results", results);
3294:
3295: final Cheesery cheesery = new Cheesery();
3296: cheesery.addCheese(new Cheese("stilton", 15));
3297: cheesery.addCheese(new Cheese("brie", 10));
3298:
3299: workingMemory.setGlobal("cheesery", cheesery);
3300:
3301: workingMemory.fireAllRules();
3302:
3303: assertEquals(2, results.size());
3304: assertEquals(2, ((List) results.get(0)).size());
3305: assertEquals(2, ((List) results.get(1)).size());
3306: }
3307:
3308: public void testNullHashing() throws Exception {
3309: final PackageBuilder builder = new PackageBuilder();
3310: builder.addPackageFromDrl(new InputStreamReader(getClass()
3311: .getResourceAsStream("test_NullHashing.drl")));
3312: final Package pkg = builder.getPackage();
3313:
3314: final RuleBase ruleBase = getRuleBase();
3315: ruleBase.addPackage(pkg);
3316: final WorkingMemory workingMemory = ruleBase
3317: .newStatefulSession();
3318:
3319: final List results = new ArrayList();
3320: workingMemory.setGlobal("results", results);
3321:
3322: workingMemory.insert(new Cheese("stilton", 15));
3323: workingMemory.insert(new Cheese("", 10));
3324: workingMemory.insert(new Cheese(null, 8));
3325:
3326: workingMemory.fireAllRules();
3327:
3328: assertEquals(3, results.size());
3329: }
3330:
3331: public void testDefaultBetaConstrains() throws Exception {
3332: final PackageBuilder builder = new PackageBuilder();
3333: builder
3334: .addPackageFromDrl(new InputStreamReader(getClass()
3335: .getResourceAsStream(
3336: "test_DefaultBetaConstraint.drl")));
3337: final Package pkg = builder.getPackage();
3338:
3339: final RuleBase ruleBase = getRuleBase();
3340: ruleBase.addPackage(pkg);
3341: final WorkingMemory workingMemory = ruleBase
3342: .newStatefulSession();
3343:
3344: final List results = new ArrayList();
3345: workingMemory.setGlobal("results", results);
3346: final FirstClass first = new FirstClass("1", "2", "3", "4", "5");
3347: final FactHandle handle = workingMemory.insert(first);
3348: workingMemory.fireAllRules();
3349: assertEquals(1, results.size());
3350: assertEquals("NOT", results.get(0));
3351:
3352: workingMemory.insert(new SecondClass());
3353: workingMemory.update(handle, first);
3354: workingMemory.fireAllRules();
3355: assertEquals(2, results.size());
3356: assertEquals("NOT", results.get(1));
3357:
3358: workingMemory.update(handle, first);
3359: workingMemory.insert(new SecondClass(null, "2", "3", "4", "5"));
3360: workingMemory.fireAllRules();
3361: assertEquals(3, results.size());
3362: assertEquals("NOT", results.get(2));
3363:
3364: workingMemory.update(handle, first);
3365: workingMemory.insert(new SecondClass("1", null, "3", "4", "5"));
3366: workingMemory.fireAllRules();
3367: assertEquals(4, results.size());
3368: assertEquals("NOT", results.get(3));
3369:
3370: workingMemory.update(handle, first);
3371: workingMemory.insert(new SecondClass("1", "2", null, "4", "5"));
3372: workingMemory.fireAllRules();
3373: assertEquals(5, results.size());
3374: assertEquals("NOT", results.get(4));
3375:
3376: workingMemory.update(handle, first);
3377: workingMemory.insert(new SecondClass("1", "2", "3", null, "5"));
3378: workingMemory.fireAllRules();
3379: assertEquals(6, results.size());
3380: assertEquals("NOT", results.get(5));
3381:
3382: workingMemory.update(handle, first);
3383: workingMemory.insert(new SecondClass("1", "2", "3", "4", null));
3384: workingMemory.fireAllRules();
3385: assertEquals(7, results.size());
3386: assertEquals("NOT", results.get(6));
3387:
3388: workingMemory.insert(new SecondClass("1", "2", "3", "4", "5"));
3389: workingMemory.update(handle, first);
3390: workingMemory.fireAllRules();
3391: assertEquals(8, results.size());
3392: assertEquals("EQUALS", results.get(7));
3393:
3394: }
3395:
3396: public void testBooleanWrapper() throws Exception {
3397: final PackageBuilder builder = new PackageBuilder();
3398: builder.addPackageFromDrl(new InputStreamReader(getClass()
3399: .getResourceAsStream("test_BooleanWrapper.drl")));
3400: final Package pkg = builder.getPackage();
3401:
3402: final RuleBase ruleBase = getRuleBase();
3403: ruleBase.addPackage(pkg);
3404: final WorkingMemory workingMemory = ruleBase
3405: .newStatefulSession();
3406:
3407: final List results = new ArrayList();
3408: workingMemory.setGlobal("results", results);
3409:
3410: Primitives p1 = new Primitives();
3411: workingMemory.insert(p1);
3412: workingMemory.fireAllRules();
3413: assertEquals(0, results.size());
3414:
3415: Primitives p2 = new Primitives();
3416: p2.setBooleanWrapper(Boolean.FALSE);
3417: workingMemory.insert(p2);
3418: workingMemory.fireAllRules();
3419: assertEquals(0, results.size());
3420:
3421: Primitives p3 = new Primitives();
3422: p3.setBooleanWrapper(Boolean.TRUE);
3423: workingMemory.insert(p3);
3424: workingMemory.fireAllRules();
3425: assertEquals(1, results.size());
3426:
3427: }
3428:
3429: public void testCrossProductRemovingIdentityEquals()
3430: throws Exception {
3431: PackageBuilder builder = new PackageBuilder();
3432: builder
3433: .addPackageFromDrl(new InputStreamReader(
3434: MiscTest.class
3435: .getResourceAsStream("test_CrossProductRemovingIdentityEquals.drl")));
3436:
3437: RuleBaseConfiguration conf = new RuleBaseConfiguration();
3438: conf.setShadowProxy(true);
3439: RuleBase rb = RuleBaseFactory.newRuleBase(conf);
3440: rb.addPackage(builder.getPackage());
3441: StatefulSession session = rb.newStatefulSession();
3442:
3443: List list1 = new ArrayList();
3444: List list2 = new ArrayList();
3445:
3446: session.setGlobal("list1", list1);
3447: session.setGlobal("list2", list2);
3448:
3449: SpecialString first42 = new SpecialString("42");
3450: SpecialString second43 = new SpecialString("42");
3451: SpecialString world = new SpecialString("World");
3452: session.insert(world);
3453: session.insert(first42);
3454: session.insert(second43);
3455:
3456: //System.out.println( "Firing rules ..." );
3457:
3458: session.fireAllRules();
3459:
3460: assertEquals(6, list1.size());
3461: assertEquals(6, list2.size());
3462:
3463: assertEquals(second43, list1.get(0));
3464: assertEquals(first42, list1.get(1));
3465: assertEquals(world, list1.get(2));
3466: assertEquals(second43, list1.get(3));
3467: assertEquals(first42, list1.get(4));
3468: assertEquals(world, list1.get(5));
3469:
3470: assertEquals(first42, list2.get(0));
3471: assertEquals(second43, list2.get(1));
3472: assertEquals(second43, list2.get(2));
3473: assertEquals(world, list2.get(3));
3474: assertEquals(world, list2.get(4));
3475: assertEquals(first42, list2.get(5));
3476: }
3477:
3478: public void testIterateObjects() throws Exception {
3479: final PackageBuilder builder = new PackageBuilder();
3480: builder.addPackageFromDrl(new InputStreamReader(getClass()
3481: .getResourceAsStream("test_IterateObjects.drl")));
3482: final Package pkg = builder.getPackage();
3483:
3484: final RuleBase ruleBase = getRuleBase();
3485: ruleBase.addPackage(pkg);
3486: final WorkingMemory workingMemory = ruleBase
3487: .newStatefulSession();
3488:
3489: final List results = new ArrayList();
3490: workingMemory.setGlobal("results", results);
3491:
3492: workingMemory.insert(new Cheese("stilton", 10));
3493:
3494: workingMemory.fireAllRules();
3495:
3496: Iterator events = workingMemory
3497: .iterateObjects(new ClassObjectFilter(
3498: PersonInterface.class));
3499:
3500: assertTrue(events.hasNext());
3501: assertEquals(1, results.size());
3502: assertEquals(results.get(0), events.next());
3503: }
3504:
3505: public void testNotInStatelessSession() throws Exception {
3506: final PackageBuilder builder = new PackageBuilder();
3507: builder
3508: .addPackageFromDrl(new InputStreamReader(getClass()
3509: .getResourceAsStream(
3510: "test_NotInStatelessSession.drl")));
3511: final Package pkg = builder.getPackage();
3512:
3513: RuleBaseConfiguration conf = new RuleBaseConfiguration();
3514: conf.setSequential(true);
3515: final RuleBase ruleBase = getRuleBase(conf);
3516: ruleBase.addPackage(pkg);
3517:
3518: StatelessSession session = ruleBase.newStatelessSession();
3519: List list = new ArrayList();
3520: session.setGlobal("list", list);
3521: session.execute("not integer");
3522: assertEquals("not integer", list.get(0));
3523: }
3524:
3525: public void testDynamicallyAddInitialFactRule() throws Exception {
3526: PackageBuilder builder = new PackageBuilder();
3527: String rule = "package org.drools.test\n global java.util.List list\n rule xxx\n when\n i:Integer()\nthen\n list.add(i);\nend";
3528: builder.addPackageFromDrl(new StringReader(rule));
3529: Package pkg = builder.getPackage();
3530:
3531: final RuleBase ruleBase = getRuleBase();
3532: ruleBase.addPackage(pkg);
3533:
3534: StatefulSession session = ruleBase.newStatefulSession();
3535: List list = new ArrayList();
3536: session.setGlobal("list", list);
3537:
3538: session.insert(new Integer(5));
3539: session.fireAllRules();
3540:
3541: assertEquals(new Integer(5), list.get(0));
3542:
3543: builder = new PackageBuilder();
3544: rule = "package org.drools.test\n global java.util.List list\n rule xxx\n when\nthen\n list.add(\"x\");\nend";
3545: builder.addPackageFromDrl(new StringReader(rule));
3546: pkg = builder.getPackage();
3547:
3548: // Make sure that this rule is fired as the Package is updated, it also tests that InitialFactImpl is still in the network
3549: // even though the first rule didn't use it.
3550: ruleBase.addPackage(pkg);
3551:
3552: assertEquals("x", list.get(1));
3553:
3554: }
3555:
3556: // FIXME
3557: public void FIXMEtestEvalRewriteWithSpecialOperators()
3558: throws Exception {
3559: final PackageBuilder builder = new PackageBuilder();
3560: builder.addPackageFromDrl(new InputStreamReader(getClass()
3561: .getResourceAsStream(
3562: "test_EvalRewriteWithSpecialOperators.drl")));
3563: final Package pkg = builder.getPackage();
3564:
3565: final RuleBase ruleBase = getRuleBase();
3566: ruleBase.addPackage(pkg);
3567: final WorkingMemory workingMemory = ruleBase
3568: .newStatefulSession();
3569:
3570: final List list = new ArrayList();
3571: workingMemory.setGlobal("results", list);
3572:
3573: final Order order1 = new Order(10, "Bob");
3574: final OrderItem item11 = new OrderItem(order1, 1);
3575: final OrderItem item12 = new OrderItem(order1, 2);
3576: order1.addItem(item11);
3577: order1.addItem(item12);
3578: final Order order2 = new Order(11, "Bob");
3579: final OrderItem item21 = new OrderItem(order2, 1);
3580: final OrderItem item22 = new OrderItem(order2, 2);
3581: order2.addItem(item21);
3582: order2.addItem(item22);
3583: final Order order3 = new Order(12, "Bob");
3584: final OrderItem item31 = new OrderItem(order3, 1);
3585: final OrderItem item32 = new OrderItem(order3, 2);
3586: final OrderItem item33 = new OrderItem(order3, 3);
3587: order3.addItem(item31);
3588: order3.addItem(item32);
3589: order3.addItem(item33);
3590: final Order order4 = new Order(13, "Bob");
3591: final OrderItem item41 = new OrderItem(order4, 1);
3592: final OrderItem item42 = new OrderItem(order4, 2);
3593: order4.addItem(item41);
3594: order4.addItem(item42);
3595: final Order order5 = new Order(14, "Mark");
3596: final OrderItem item51 = new OrderItem(order5, 1);
3597: final OrderItem item52 = new OrderItem(order5, 2);
3598: order5.addItem(item51);
3599: order5.addItem(item52);
3600: workingMemory.insert(order1);
3601: workingMemory.insert(item11);
3602: workingMemory.insert(item12);
3603: workingMemory.insert(order2);
3604: workingMemory.insert(item21);
3605: workingMemory.insert(item22);
3606: workingMemory.insert(order3);
3607: workingMemory.insert(item31);
3608: workingMemory.insert(item32);
3609: workingMemory.insert(item33);
3610: workingMemory.insert(order4);
3611: workingMemory.insert(item41);
3612: workingMemory.insert(item42);
3613: workingMemory.insert(order5);
3614: workingMemory.insert(item51);
3615: workingMemory.insert(item52);
3616:
3617: workingMemory.fireAllRules();
3618:
3619: assertEquals(9, list.size());
3620: int index = 0;
3621: assertEquals(item11, list.get(index++));
3622: assertEquals(item12, list.get(index++));
3623: assertEquals(item21, list.get(index++));
3624: assertEquals(item22, list.get(index++));
3625: assertEquals(item31, list.get(index++));
3626: assertEquals(item33, list.get(index++));
3627: assertEquals(item41, list.get(index++));
3628: assertEquals(order5, list.get(index++));
3629: assertEquals(order5, list.get(index++));
3630:
3631: }
3632:
3633: public void testImportColision() throws Exception {
3634:
3635: final PackageBuilder builder = new PackageBuilder();
3636: final PackageBuilder builder2 = new PackageBuilder();
3637: builder.addPackageFromDrl(new InputStreamReader(getClass()
3638: .getResourceAsStream("nested1.drl")));
3639: builder2.addPackageFromDrl(new InputStreamReader(getClass()
3640: .getResourceAsStream("nested2.drl")));
3641: final Package pkg = builder.getPackage();
3642: final Package pkg2 = builder2.getPackage();
3643:
3644: final RuleBase ruleBase = getRuleBase();
3645: ruleBase.addPackage(pkg);
3646: ruleBase.addPackage(pkg2);
3647:
3648: final WorkingMemory workingMemory = ruleBase
3649: .newStatefulSession();
3650:
3651: workingMemory.insert(new FirstClass());
3652: workingMemory.insert(new SecondClass());
3653: workingMemory.insert(new FirstClass.AlternativeKey());
3654: workingMemory.insert(new SecondClass.AlternativeKey());
3655:
3656: workingMemory.fireAllRules();
3657: }
3658:
3659: public void testAutovivificationOfVariableRestrictions()
3660: throws Exception {
3661: final PackageBuilder builder = new PackageBuilder();
3662: builder.addPackageFromDrl(new InputStreamReader(getClass()
3663: .getResourceAsStream("test_AutoVivificationVR.drl")));
3664: final Package pkg = builder.getPackage();
3665:
3666: final RuleBase ruleBase = getRuleBase();
3667: ruleBase.addPackage(pkg);
3668: final WorkingMemory workingMemory = ruleBase
3669: .newStatefulSession();
3670:
3671: final List results = new ArrayList();
3672: workingMemory.setGlobal("results", results);
3673:
3674: workingMemory.insert(new Cheese("stilton", 10, 8));
3675:
3676: workingMemory.fireAllRules();
3677:
3678: assertEquals(1, results.size());
3679: }
3680:
3681: public void testShadowProxyOnCollections() throws Exception {
3682: final PackageBuilder builder = new PackageBuilder();
3683: builder.addPackageFromDrl(new InputStreamReader(getClass()
3684: .getResourceAsStream(
3685: "test_ShadowProxyOnCollections.drl")));
3686: final Package pkg = builder.getPackage();
3687:
3688: final RuleBase ruleBase = getRuleBase();
3689: ruleBase.addPackage(pkg);
3690: final WorkingMemory workingMemory = ruleBase
3691: .newStatefulSession();
3692:
3693: final List results = new ArrayList();
3694: workingMemory.setGlobal("results", results);
3695:
3696: final Cheesery cheesery = new Cheesery();
3697: workingMemory.insert(cheesery);
3698:
3699: workingMemory.fireAllRules();
3700:
3701: assertEquals(1, results.size());
3702: assertEquals(1, cheesery.getCheeses().size());
3703: assertEquals(results.get(0), cheesery.getCheeses().get(0));
3704: }
3705:
3706: }
|