コード例 #1
0
  @Test
  public void testCollectWithNestedFromWithParams() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("test_CollectWithNestedFrom.drl")));
    final Package pkg = builder.getPackage();

    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);

    final WorkingMemory workingMemory = ruleBase.newStatefulSession();
    final List results = new ArrayList();
    workingMemory.setGlobal("results", results);

    final Person bob = new Person("bob", "stilton");

    Cheesery cheesery = new Cheesery();
    cheesery.addCheese(new Cheese("stilton", 10));
    cheesery.addCheese(new Cheese("brie", 20));
    cheesery.addCheese(new Cheese("muzzarela", 8));
    cheesery.addCheese(new Cheese("stilton", 5));
    cheesery.addCheese(new Cheese("provolone", 1));

    workingMemory.insert(bob);
    workingMemory.insert(cheesery);

    workingMemory.fireAllRules();

    assertEquals(1, results.size());
    List cheeses = (List) results.get(0);
    assertEquals(2, cheeses.size());
    assertEquals(bob.getLikes(), ((Cheese) cheeses.get(0)).getType());
    assertEquals(bob.getLikes(), ((Cheese) cheeses.get(1)).getType());
  }
コード例 #2
0
  @Test
  public void testMVELCollect() throws Exception {

    // read in the source
    final Reader reader =
        new InputStreamReader(getClass().getResourceAsStream("test_MVELCollect.drl"));
    final RuleBase ruleBase = loadRuleBase(reader);

    final WorkingMemory wm = ruleBase.newStatefulSession();
    final List results = new ArrayList();

    wm.setGlobal("results", results);

    wm.insert(new Cheese("stilton", 10));
    wm.insert(new Cheese("stilton", 7));
    wm.insert(new Cheese("stilton", 8));
    wm.insert(new Cheese("brie", 5));
    wm.insert(new Cheese("provolone", 150));
    wm.insert(new Cheese("provolone", 20));
    wm.insert(new Person("Bob", "stilton"));
    wm.insert(new Person("Mark", "provolone"));

    wm.fireAllRules();

    assertEquals(1, results.size());
    assertEquals(6, ((List) results.get(0)).size());
  }
コード例 #3
0
  @Test
  public void testExists() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("exists_rule_test.drl")));
    final Package pkg = builder.getPackage();

    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("list", list);

    final Cheese cheddar = new Cheese("cheddar", 7);
    final FactHandle cheddarHandle = workingMemory.insert(cheddar);
    workingMemory.fireAllRules();

    assertEquals(0, list.size());

    final Cheese stilton = new Cheese("stilton", 5);
    final FactHandle stiltonHandle = workingMemory.insert(stilton);
    workingMemory.fireAllRules();

    assertEquals(1, list.size());

    final Cheese brie = new Cheese("brie", 5);
    final FactHandle brieHandle = workingMemory.insert(brie);
    workingMemory.fireAllRules();

    assertEquals(1, list.size());
  }
コード例 #4
0
  @Test
  public void testNotWithBindings() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("not_with_bindings_rule_test.drl")));
    final Package pkg = builder.getPackage();

    final Rule rule = pkg.getRules()[0];
    assertTrue(rule.isValid());
    assertEquals(0, builder.getErrors().getErrors().length);
    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("list", list);

    final Cheese stilton = new Cheese("stilton", 5);
    final FactHandle stiltonHandle = workingMemory.insert(stilton);
    final Cheese cheddar = new Cheese("cheddar", 7);
    final FactHandle cheddarHandle = workingMemory.insert(cheddar);

    final PersonInterface paul = new Person("paul", "stilton", 12);
    workingMemory.insert(paul);
    workingMemory.fireAllRules();

    assertEquals(0, list.size());

    workingMemory.retract(stiltonHandle);

    workingMemory.fireAllRules();

    assertEquals(1, list.size());
  }
コード例 #5
0
  @Test
  public void testForallSinglePatternWithExists() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(
            getClass().getResourceAsStream("test_ForallSinglePatternWithExists.drl")));
    final Package pkg = builder.getPackage();

    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("results", list);

    workingMemory.insert(new Cheese("stilton", 10));
    workingMemory.insert(new Cheese("brie", 10));
    workingMemory.insert(new Cheese("brie", 10));
    workingMemory.insert(new Order(1, "bob"));
    workingMemory.insert(new Person("bob", "stilton", 10));
    workingMemory.insert(new Person("mark", "stilton"));

    workingMemory.fireAllRules();

    assertEquals(1, list.size());
  }
コード例 #6
0
  @Test
  public void testNot() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("not_rule_test.drl")));
    if (builder.hasErrors()) {
      fail(builder.getErrors().toString());
    }
    final Package pkg = builder.getPackage();

    final RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("list", list);

    final Cheese stilton = new Cheese("stilton", 5);
    final FactHandle stiltonHandle = workingMemory.insert(stilton);
    final Cheese cheddar = new Cheese("cheddar", 7);
    final FactHandle cheddarHandle = workingMemory.insert(cheddar);
    workingMemory.fireAllRules();

    assertEquals(0, list.size());

    workingMemory.retract(stiltonHandle);

    workingMemory.fireAllRules();

    assertEquals(4, list.size());
    assertTrue(list.contains(new Integer(5)));
    assertTrue(list.contains(new Integer(6)));
    assertTrue(list.contains(new Integer(7)));
    assertTrue(list.contains(new Integer(8)));
  }
コード例 #7
0
  @Test
  public void testOr() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("test_OrNesting.drl")));
    final Package pkg = builder.getPackage();

    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("results", list);

    final Cheese cheddar = new Cheese("cheddar", 7);
    final Cheese provolone = new Cheese("provolone", 5);
    final Cheese brie = new Cheese("brie", 15);
    final Person mark = new Person("mark", "stilton");

    FactHandle ch = workingMemory.insert(cheddar);
    FactHandle ph = workingMemory.insert(provolone);
    FactHandle bh = workingMemory.insert(brie);
    FactHandle markh = workingMemory.insert(mark);

    workingMemory.fireAllRules();
    assertEquals(1, list.size());
  }
コード例 #8
0
  @Test
  public void testForall() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("test_Forall.drl")));
    final Package pkg = builder.getPackage();

    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("results", list);

    final State state = new State("SP");
    workingMemory.insert(state);

    final Person bob = new Person("Bob");
    bob.setStatus(state.getState());
    bob.setLikes("stilton");
    workingMemory.insert(bob);

    workingMemory.fireAllRules();

    assertEquals(0, list.size());

    workingMemory.insert(new Cheese(bob.getLikes(), 10));
    workingMemory.fireAllRules();

    assertEquals(1, list.size());
  }
コード例 #9
0
  @Test
  public void testCollectModifyAlphaRestriction() throws Exception {
    // read in the source
    final Reader reader =
        new InputStreamReader(getClass().getResourceAsStream("test_CollectAlphaRestriction.drl"));
    RuleBase ruleBase = loadRuleBase(reader);

    final WorkingMemory wm = ruleBase.newStatefulSession();
    final List results = new ArrayList();

    wm.setGlobal("results", results);

    final Cheese[] cheese =
        new Cheese[] {
          new Cheese("stilton", 10),
          new Cheese("stilton", 2),
          new Cheese("stilton", 5),
          new Cheese("brie", 15),
          new Cheese("brie", 16),
          new Cheese("provolone", 8)
        };

    final FactHandle[] cheeseHandles = new FactHandle[cheese.length];
    for (int i = 0; i < cheese.length; i++) {
      cheeseHandles[i] = wm.insert(cheese[i]);
    }

    // ---------------- 1st scenario
    int fireCount = 0;
    wm.fireAllRules();
    assertEquals(++fireCount, results.size());
    assertEquals(3, ((Collection) results.get(fireCount - 1)).size());
    assertEquals(ArrayList.class.getName(), results.get(fireCount - 1).getClass().getName());

    // ---------------- 2nd scenario
    final int index = 1;
    cheese[index].setType("brie");
    wm.update(cheeseHandles[index], cheese[index]);
    wm.fireAllRules();

    assertEquals(++fireCount, results.size());
    assertEquals(2, ((Collection) results.get(fireCount - 1)).size());
    assertEquals(ArrayList.class.getName(), results.get(fireCount - 1).getClass().getName());

    // ---------------- 3rd scenario
    wm.retract(cheeseHandles[2]);
    wm.fireAllRules();

    assertEquals(++fireCount, results.size());
    assertEquals(1, ((Collection) results.get(fireCount - 1)).size());
    assertEquals(ArrayList.class.getName(), results.get(fireCount - 1).getClass().getName());
  }
コード例 #10
0
  @Test
  public void testFromInsideNotAndExists() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("test_FromInsideNotAndExists.drl")));
    final Package pkg = builder.getPackage();

    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("results", list);

    final Cheese cheddar = new Cheese("cheddar", 7);
    final Cheese provolone = new Cheese("provolone", 5);
    final Cheesery cheesery = new Cheesery();

    cheesery.addCheese(cheddar);
    cheesery.addCheese(provolone);

    FactHandle handle = workingMemory.insert(cheesery);
    workingMemory.fireAllRules();
    assertEquals(0, list.size());

    cheesery.addCheese(new Cheese("stilton", 10));
    cheesery.removeCheese(cheddar);
    workingMemory.update(handle, cheesery);
    workingMemory.fireAllRules();
    assertEquals(2, list.size());
  }
コード例 #11
0
ファイル: RuleTest.java プロジェクト: mok89/drools
  @Test
  public void testTimeMachine() {
    SessionConfiguration conf = SessionConfiguration.newInstance();
    conf.setClockType(ClockType.PSEUDO_CLOCK);
    WorkingMemory wm = new KnowledgeBaseImpl("x", null).newStatefulSession(conf, null);

    final Calendar future = Calendar.getInstance();
    ((PseudoClockScheduler) wm.getSessionClock()).setStartupTime(future.getTimeInMillis());

    final RuleImpl rule = new RuleImpl("myrule");
    rule.setEnabled(EnabledBoolean.ENABLED_TRUE);
    assertTrue(rule.isEffective(null, new RuleTerminalNode(), wm));

    future.setTimeInMillis(future.getTimeInMillis() + 100000000);
    rule.setDateEffective(future);
    assertFalse(rule.isEffective(null, new RuleTerminalNode(), wm));

    ((PseudoClockScheduler) wm.getSessionClock())
        .advanceTime(1000000000000L, TimeUnit.MILLISECONDS);

    assertTrue(rule.isEffective(null, new RuleTerminalNode(), wm));
  }
コード例 #12
0
  @Test
  public void testExistsWithBinding() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("test_ExistsWithBindings.drl")));
    final Package pkg = builder.getPackage();

    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("results", list);

    final Cheese c = new Cheese("stilton", 10);
    final Person p = new Person("Mark", "stilton");
    workingMemory.insert(c);
    workingMemory.insert(p);
    workingMemory.fireAllRules();

    assertTrue(list.contains(c.getType()));
    assertEquals(1, list.size());
  }
コード例 #13
0
  @Test
  public void testExists2() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("test_exists.drl")));
    final Package pkg = builder.getPackage();

    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("list", list);

    final Cheese cheddar = new Cheese("cheddar", 7);
    final Cheese provolone = new Cheese("provolone", 5);
    final Person edson = new Person("Edson", "cheddar");
    final Person bob = new Person("Bob", "muzzarela");

    workingMemory.insert(cheddar);
    workingMemory.fireAllRules();
    assertEquals(0, list.size());

    workingMemory.insert(provolone);
    workingMemory.fireAllRules();
    assertEquals(0, list.size());

    workingMemory.insert(edson);
    workingMemory.fireAllRules();
    assertEquals(1, list.size());

    workingMemory.insert(bob);
    workingMemory.fireAllRules();
    assertEquals(1, list.size());
  }
コード例 #14
0
ファイル: Rule.java プロジェクト: rus-mihai/drools
  /**
   * This returns true is the rule is effective. If the rule is not effective, it cannot activate.
   *
   * <p>This uses the dateEffective, dateExpires and enabled flag to decide this.
   */
  public boolean isEffective(Tuple tuple, RuleTerminalNode rtn, WorkingMemory workingMemory) {
    if (!this.enabled.getValue(tuple, rtn.getEnabledDeclarations(), this, workingMemory)) {
      return false;
    }
    if (this.dateEffective == null && this.dateExpires == null) {
      return true;
    } else {
      Calendar now = Calendar.getInstance();
      now.setTimeInMillis(workingMemory.getSessionClock().getCurrentTime());

      if (this.dateEffective != null && this.dateExpires != null) {
        return (now.after(this.dateEffective) && now.before(this.dateExpires));
      } else if (this.dateEffective != null) {
        return (now.after(this.dateEffective));
      } else {
        return (now.before(this.dateExpires));
      }
    }
  }
コード例 #15
0
  @Test
  public void testCollectWithContainsOperators() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("test_CollectContainsOperator.drl")));
    final Package pkg = builder.getPackage();

    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("results", list);

    final Order order1 = new Order(1, "bob");
    final OrderItem item11 = new OrderItem(order1, 1);
    final OrderItem item12 = new OrderItem(order1, 2);
    final Order order2 = new Order(2, "mark");
    final OrderItem item21 = new OrderItem(order2, 1);
    final OrderItem item22 = new OrderItem(order2, 2);

    workingMemory.insert(order1);
    workingMemory.insert(item11);
    workingMemory.insert(item12);
    workingMemory.insert(order2);
    workingMemory.insert(item21);
    workingMemory.insert(item22);

    workingMemory.fireAllRules();

    int index = 0;
    assertEquals(8, list.size());
    assertSame(order1, list.get(index++));
    assertSame(item11, list.get(index++));
    assertSame(order2, list.get(index++));
    assertSame(item21, list.get(index++));
    assertSame(order1, list.get(index++));
    assertSame(item11, list.get(index++));
    assertSame(order2, list.get(index++));
    assertSame(item21, list.get(index++));
  }
コード例 #16
0
  @Test
  @Ignore("This test requires us to fix the propagation order")
  public void testForallSinglePattern() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("test_ForallSinglePattern.drl")));
    final Package pkg = builder.getPackage();

    RuleBase ruleBase = getSinglethreadRuleBase();
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("results", list);
    int fired = 0;

    // no cheeses, so should fire
    workingMemory.fireAllRules();
    assertEquals(++fired, list.size());

    // only stilton, so should not fire again
    FactHandle stilton1 = workingMemory.insert(new Cheese("stilton", 10));
    workingMemory.fireAllRules();
    assertEquals(fired, list.size());

    // only stilton, so should not fire again
    FactHandle stilton2 = workingMemory.insert(new Cheese("stilton", 11));
    workingMemory.fireAllRules();
    assertEquals(fired, list.size());

    // still only stilton, so should not fire
    workingMemory.retract(stilton1);
    workingMemory.fireAllRules();
    assertEquals(
        ++fired, // we need to fix forall to not fire in this situation
        list.size());

    // there is a brie, so should not fire
    FactHandle brie = workingMemory.insert(new Cheese("brie", 10));
    workingMemory.fireAllRules();
    assertEquals(fired, list.size());

    // no brie anymore, so should fire
    workingMemory.retract(brie);
    workingMemory.fireAllRules();
    assertEquals(++fired, list.size());

    // no more cheese, but since it already fired, should not fire again
    workingMemory.retract(stilton2);
    workingMemory.fireAllRules();
    assertEquals(fired, list.size());
  }
コード例 #17
0
  @Test
  public void testRemoveIdentitiesSubNetwork() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(
            getClass().getResourceAsStream("test_removeIdentitiesSubNetwork.drl")));
    final Package pkg = builder.getPackage();

    final RuleBaseConfiguration config = new RuleBaseConfiguration();
    config.setRemoveIdentities(true);
    RuleBase ruleBase = getRuleBase(config);
    ruleBase.addPackage(pkg);
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    final WorkingMemory workingMemory = ruleBase.newStatefulSession();

    final List list = new ArrayList();
    workingMemory.setGlobal("results", list);

    final Person bob = new Person("bob", "stilton");
    workingMemory.insert(bob);

    final Person mark = new Person("mark", "stilton");
    workingMemory.insert(mark);

    final Cheese stilton1 = new Cheese("stilton", 6);
    final FactHandle stilton1Handle = workingMemory.insert(stilton1);
    final Cheese stilton2 = new Cheese("stilton", 7);
    final FactHandle stilton2Handle = workingMemory.insert(stilton2);

    workingMemory.fireAllRules();
    assertEquals(0, list.size());

    workingMemory.retract(stilton1Handle);

    workingMemory.fireAllRules();
    assertEquals(1, list.size());
    assertEquals(mark, list.get(0));

    workingMemory.retract(stilton2Handle);

    workingMemory.fireAllRules();
    assertEquals(2, list.size());
    assertEquals(bob, list.get(1));
  }