コード例 #1
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)));
  }
コード例 #2
0
  @Test
  public void testNestedCorelatedRulesWithForall() throws Exception {

    PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(
            FirstOrderLogicTest.class.getResourceAsStream(
                "test_NestedCorrelatedRulesWithForall.drl")));

    RuleBase ruleBase = RuleBaseFactory.newRuleBase();
    ruleBase.addPackage(builder.getPackage());
    ruleBase = SerializationHelper.serializeObject(ruleBase);
    StatefulSession session = ruleBase.newStatefulSession();

    List list1 = new ArrayList();
    List list2 = new ArrayList();
    List list3 = new ArrayList();
    List list4 = new ArrayList();

    session.setGlobal("list1", list1);
    session.setGlobal("list2", list2);
    session.setGlobal("list3", list3);
    session.setGlobal("list4", list4);

    SpecialString first42 = new SpecialString("42");
    SpecialString second42 = new SpecialString("42");
    SpecialString world = new SpecialString("World");

    // System.out.println( "Inserting ..." );

    session.insert(world);
    session.insert(first42);
    session.insert(second42);

    // System.out.println( "Done." );

    // System.out.println( "Firing rules ..." );

    // check all lists are empty
    assertTrue(list1.isEmpty());
    assertTrue(list2.isEmpty());
    assertTrue(list3.isEmpty());
    assertTrue(list4.isEmpty());

    session.fireAllRules();

    // System.out.println( "Done." );

    // check first list is populated correctly
    assertEquals(0, list1.size());

    // check second list is populated correctly
    assertEquals(0, list2.size());

    // check third list is populated correctly
    assertEquals(1, list3.size());

    // check fourth list is populated correctly
    assertEquals(0, list4.size());
  }
コード例 #3
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());
  }
コード例 #4
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());
  }
コード例 #5
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());
  }
コード例 #6
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());
  }
コード例 #7
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());
  }
コード例 #8
0
  @Test
  public void testCollectNodeSharing() throws Exception {
    final PackageBuilder builder = new PackageBuilder();
    builder.addPackageFromDrl(
        new InputStreamReader(getClass().getResourceAsStream("test_collectNodeSharing.drl")));
    final Package pkg = builder.getPackage();

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

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

    workingMemory = SerializationHelper.getSerialisedStatefulSession(workingMemory);
    results = (List) workingMemory.getGlobal("results");

    workingMemory.insert(new Cheese("stilton", 10));
    workingMemory = SerializationHelper.getSerialisedStatefulSession(workingMemory);
    results = (List) workingMemory.getGlobal("results");

    workingMemory.insert(new Cheese("brie", 15));

    workingMemory.fireAllRules();

    workingMemory = SerializationHelper.getSerialisedStatefulSession(workingMemory);
    results = (List) workingMemory.getGlobal("results");

    assertEquals(1, results.size());

    assertEquals(2, ((List) results.get(0)).size());
  }
コード例 #9
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());
  }
コード例 #10
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());
  }
コード例 #11
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());
  }
コード例 #12
0
ファイル: LargeRuleBase.java プロジェクト: henry-liu/drools
  private static void bigBlobCompile() throws DroolsParserException, IOException, Exception {
    StringBuilder buf = new StringBuilder();
    buf.append(getHeader());

    for (int i = 0; i < RULE_COUNT; i++) {
      String name = "x" + i;
      int status = i;

      String r = getTemplate1(name, status);
      buf.append(r);
    }

    /* love you */ long time = System.currentTimeMillis();

    DrlParser ps = new DrlParser(LanguageLevelOption.DRL5);
    PackageDescr pkg = ps.parse(new StringReader(buf.toString()));

    System.err.println("Time taken for parsing: " + (System.currentTimeMillis() - time));

    time = System.currentTimeMillis();
    PackageBuilder b = new PackageBuilder();
    b.addPackage(pkg);
    assertFalse(b.getErrors().toString(), b.hasErrors());

    System.err.println("Time taken for compiling: " + (System.currentTimeMillis() - time));
    time = System.currentTimeMillis();

    Package p = b.getPackage();
    RuleBase rb = RuleBaseFactory.newRuleBase();

    rb.addPackage(p);

    System.err.println("Time taken rete building: " + (System.currentTimeMillis() - time));

    File f = new File("foo.rulebase");
    if (f.exists()) f.delete();

    time = System.currentTimeMillis();
    ObjectOutput out = new DroolsObjectOutputStream(new FileOutputStream(f));
    out.writeObject(rb);
    out.flush();
    out.close();
    System.err.println("Time taken serializing rulebase: " + (System.currentTimeMillis() - time));

    time = System.currentTimeMillis();
    ObjectInputStream in = new ObjectInputStream(new FileInputStream(f));
    RuleBase rb_ = (RuleBase) in.readObject();
    System.err.println(
        "Time taken de-serializing rulebase: " + (System.currentTimeMillis() - time));
  }
コード例 #13
0
ファイル: MVELDebugTest.java プロジェクト: bohrqiu/drools
 @Test
 public void testDebug() throws Exception {
   String rule =
       "package com.sample; dialect \"mvel\" rule myRule when then\n System.out.println( \"test\" ); end";
   PackageBuilder builder = new PackageBuilder();
   DrlParser parser = new DrlParser(LanguageLevelOption.DRL5);
   PackageDescr packageDescr = parser.parse(rule);
   RuleDescr ruleDescr = packageDescr.getRules().get(0);
   builder = new PackageBuilder();
   builder.addPackage(packageDescr);
   Package pkg = builder.getPackage();
   MVELConsequence consequence = (MVELConsequence) pkg.getRule("myRule").getConsequence();
   String sourceName = ((CompiledExpression) consequence.getCompExpr()).getSourceName();
   System.out.println(sourceName);
   String ruleName = ruleDescr.getNamespace() + "." + ruleDescr.getClassName();
   System.out.println(ruleName);
   assertEquals(sourceName, ruleName);
 }
コード例 #14
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));
  }
コード例 #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
ファイル: LargeRuleBase.java プロジェクト: henry-liu/drools
  private static void smallBlobCompile() throws DroolsParserException, IOException, Exception {

    /* love you */ long time = System.currentTimeMillis();
    PackageBuilder b = new PackageBuilder();
    b.addPackageFromDrl(new StringReader(getHeader()));
    for (int i = 0; i < RULE_COUNT; i++) {
      String name = "x" + i;
      int status = i;

      String r = getTemplate2(name, i, status);
      b.addPackageFromDrl(new StringReader(r));
      if (i % 1000 == 0) System.err.println("Rule #" + i);
    }

    assertFalse(b.getErrors().toString(), b.hasErrors());

    System.err.println("Time taken for compiling: " + (System.currentTimeMillis() - time));
    time = System.currentTimeMillis();

    Package p = b.getPackage();
    RuleBase rb = RuleBaseFactory.newRuleBase();

    rb.addPackage(p);

    System.err.println("Time taken rete building: " + (System.currentTimeMillis() - time));
  }
コード例 #17
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());
  }
コード例 #18
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());
  }
コード例 #19
0
  @Test
  public void test3() throws Exception {
    String process1 =
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
            + "<process xmlns=\"http://drools.org/drools-5.0/process\"\n"
            + "  xmlns:xs=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
            + "  xs:schemaLocation=\"http://drools.org/drools-5.0/process drools-processes-5.0.xsd\"\n"
            + "  type=\"RuleFlow\" name=\"ruleflow\" id=\"com.sample.ruleflow\" package-name=\"com.sample\" >\n"
            + "\n"
            + "  <header>\n"
            + "    <imports>\n"
            + "      <import name=\"org.jbpm.integrationtests.test.Person\" />\n"
            + "    </imports>\n"
            + "    <swimlanes>\n"
            + "      <swimlane name=\"swimlane\" />\n"
            + "    </swimlanes>\n"
            + "  </header>\n"
            + "\n"
            + "  <nodes>\n"
            + "    <start id=\"1\" name=\"Start\" />\n"
            + "    <end id=\"4\" name=\"End\" />\n"
            + "    <split id=\"5\" name=\"AND\" type=\"1\" />\n"
            + "    <subProcess id=\"6\" name=\"SubProcess\" processId=\"com.sample.subflow\" />\n"
            + "    <actionNode id=\"7\" name=\"Action\" >\n"
            + "      <action type=\"expression\" dialect=\"mvel\" >System.out.println(\"Executing action 1\");</action>\n"
            + "	 </actionNode>\n"
            + "    <join id=\"8\" name=\"AND\" type=\"1\" />\n"
            + "    <actionNode id=\"9\" name=\"Action\" >\n"
            + "      <action type=\"expression\" dialect=\"mvel\" >System.out.println(\"Executing action 2\");</action>\n"
            + "    </actionNode>\n"
            + "    <ruleSet id=\"10\" name=\"RuleSet\" ruleFlowGroup=\"flowgroup\" />\n"
            + "    <milestone id=\"11\" name=\"Event Wait\" >\n"
            + "      <constraint type=\"rule\" dialect=\"mvel\" >Person( )</constraint>\n"
            + "    </milestone>\n"
            + "    <workItem id=\"12\" name=\"Log\" >\n"
            + "      <work name=\"Log\" >\n"
            + "        <parameter name=\"Message\" >\n"
            + "          <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "          <value>This is a log message</value>\n"
            + "        </parameter>\n"
            + "      </work>\n"
            + "    </workItem>\n"
            + "    <composite id=\"13\" name=\"CompositeNode\" >\n"
            + "      <variables>\n"
            + "        <variable name=\"x\" >\n"
            + "          <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "          <value>x-value</value>\n"
            + "        </variable>\n"
            + "      </variables>\n"
            + "      <nodes>\n"
            + "        <humanTask id=\"1\" name=\"Human Task\" swimlane=\"swimlane\" >\n"
            + "          <work name=\"Human Task\" >\n"
            + "            <parameter name=\"ActorId\" >\n"
            + "              <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "              <value>John Doe</value>\n"
            + "            </parameter>\n"
            + "            <parameter name=\"Priority\" >\n"
            + "              <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "            </parameter>\n"
            + "            <parameter name=\"TaskName\" >\n"
            + "              <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "              <value>Do something !</value>\n"
            + "            </parameter>\n"
            + "            <parameter name=\"Comment\" >\n"
            + "              <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "            </parameter>\n"
            + "          </work>\n"
            + "        </humanTask>\n"
            + "        <humanTask id=\"2\" name=\"Human Task\" swimlane=\"swimlane\" >\n"
            + "          <work name=\"Human Task\" >\n"
            + "            <parameter name=\"ActorId\" >\n"
            + "              <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "            </parameter>\n"
            + "            <parameter name=\"Priority\" >\n"
            + "              <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "            </parameter>\n"
            + "            <parameter name=\"TaskName\" >\n"
            + "              <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "              <value>Do something else !</value>\n"
            + "            </parameter>\n"
            + "            <parameter name=\"Comment\" >\n"
            + "              <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "            </parameter>\n"
            + "          </work>\n"
            + "          <mapping type=\"in\" from=\"x\" to=\"Priority\" />\n"
            + "        </humanTask>\n"
            + "      </nodes>\n"
            + "      <connections>\n"
            + "        <connection from=\"1\" to=\"2\" />\n"
            + "      </connections>\n"
            + "      <in-ports>\n"
            + "        <in-port type=\"DROOLS_DEFAULT\" nodeId=\"1\" nodeInType=\"DROOLS_DEFAULT\" />\n"
            + "      </in-ports>\n"
            + "      <out-ports>\n"
            + "        <out-port type=\"DROOLS_DEFAULT\" nodeId=\"2\" nodeOutType=\"DROOLS_DEFAULT\" />\n"
            + "      </out-ports>\n"
            + "    </composite>\n"
            + "  </nodes>\n"
            + "\n"
            + "  <connections>\n"
            + "    <connection from=\"9\" to=\"4\" />\n"
            + "    <connection from=\"1\" to=\"5\" />\n"
            + "    <connection from=\"5\" to=\"6\" />\n"
            + "    <connection from=\"5\" to=\"7\" />\n"
            + "    <connection from=\"7\" to=\"8\" />\n"
            + "    <connection from=\"6\" to=\"8\" />\n"
            + "    <connection from=\"10\" to=\"8\" />\n"
            + "    <connection from=\"11\" to=\"8\" />\n"
            + "    <connection from=\"12\" to=\"8\" />\n"
            + "    <connection from=\"13\" to=\"8\" />\n"
            + "    <connection from=\"8\" to=\"9\" />\n"
            + "    <connection from=\"5\" to=\"10\" />\n"
            + "    <connection from=\"5\" to=\"11\" />\n"
            + "    <connection from=\"5\" to=\"12\" />\n"
            + "    <connection from=\"5\" to=\"13\" />\n"
            + "  </connections>\n"
            + "\n"
            + "</process>\n";
    final PackageBuilder builder = new PackageBuilder();
    builder.addProcessFromXml(new StringReader(process1));

    String process2 =
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
            + "<process xmlns=\"http://drools.org/drools-5.0/process\"\n"
            + "         xmlns:xs=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
            + "         xs:schemaLocation=\"http://drools.org/drools-5.0/process drools-processes-5.0.xsd\"\n"
            + "         type=\"RuleFlow\" name=\"flow\" id=\"com.sample.subflow\" package-name=\"com.sample\" >\n"
            + "\n"
            + "  <header>\n"
            + "    <imports>\n"
            + "      <import name=\"org.jbpm.integrationtests.test.Person\" />\n"
            + "    </imports>\n"
            + "  </header>\n"
            + "\n"
            + "  <nodes>\n"
            + "    <start id=\"1\" name=\"Start\" />\n"
            + "    <milestone id=\"2\" name=\"Event Wait\" >\n"
            + "      <constraint type=\"rule\" dialect=\"mvel\" >Person( )</constraint>\n"
            + "    </milestone>\n"
            + "    <end id=\"3\" name=\"End\" />\n"
            + "  </nodes>\n"
            + "\n"
            + "  <connections>\n"
            + "    <connection from=\"1\" to=\"2\" />\n"
            + "    <connection from=\"2\" to=\"3\" />\n"
            + "  </connections>\n"
            + "\n"
            + "</process>\n";
    builder.addProcessFromXml(new StringReader(process2));

    String rule =
        "package com.sample\n"
            + "import org.jbpm.integrationtests.test.Person;\n"
            + "rule \"Hello\" ruleflow-group \"flowgroup\"\n"
            + "    when\n"
            + "    then\n"
            + "        System.out.println( \"Hello\" );\n"
            + "end";
    builder.addPackageFromDrl(new StringReader(rule));

    final Package pkg = builder.getPackage();
    final RuleBase ruleBase = RuleBaseFactory.newRuleBase();
    ruleBase.addPackage(pkg);

    StatefulSession session = ruleBase.newStatefulSession();
    TestWorkItemHandler handler1 = new TestWorkItemHandler();
    session.getWorkItemManager().registerWorkItemHandler("Log", handler1);
    TestWorkItemHandler handler2 = new TestWorkItemHandler();
    session.getWorkItemManager().registerWorkItemHandler("Human Task", handler2);
    session.startProcess("com.sample.ruleflow");

    assertEquals(2, session.getProcessInstances().size());
    assertTrue(handler1.getWorkItem() != null);
    long workItemId = handler2.getWorkItem().getId();
    assertTrue(workItemId != -1);

    session = getSerialisedStatefulSession(session);
    session.getWorkItemManager().registerWorkItemHandler("Human Task", handler2);
    assertEquals(2, session.getProcessInstances().size());

    handler2.reset();
    session.getWorkItemManager().completeWorkItem(workItemId, null);
    assertTrue(handler2.getWorkItem() != null);
    assertEquals("John Doe", handler2.getWorkItem().getParameter("ActorId"));
    assertEquals("x-value", handler2.getWorkItem().getParameter("Priority"));

    session.getWorkItemManager().completeWorkItem(handler1.getWorkItem().getId(), null);
    session.getWorkItemManager().completeWorkItem(handler2.getWorkItem().getId(), null);
    session.insert(new Person());
    session.fireAllRules();

    assertEquals(0, session.getProcessInstances().size());
  }
コード例 #20
0
  @Test
  public void test5() throws Exception {
    String process =
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
            + "<process xmlns=\"http://drools.org/drools-5.0/process\"\n"
            + "  xmlns:xs=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
            + "  xs:schemaLocation=\"http://drools.org/drools-5.0/process drools-processes-5.0.xsd\"\n"
            + "  type=\"RuleFlow\" name=\"ruleflow\" id=\"com.sample.ruleflow\" package-name=\"com.sample\" >\n"
            + "\n"
            + "    <header>\n"
            + "    </header>\n"
            + "\n"
            + "    <nodes>\n"
            + "      <start id=\"1\" name=\"Start\" />\n"
            + "      <timerNode id=\"4\" name=\"Timer\" delay=\"200\" />\n"
            + "      <end id=\"3\" name=\"End\" />\n"
            + "    </nodes>\n"
            + "\n"
            + "    <connections>\n"
            + "      <connection from=\"1\" to=\"4\" />\n"
            + "      <connection from=\"4\" to=\"3\" />\n"
            + "    </connections>\n"
            + "\n"
            + "</process>\n";
    final PackageBuilder builder = new PackageBuilder();
    builder.addProcessFromXml(new StringReader(process));
    final Package pkg = builder.getPackage();
    final RuleBase ruleBase = RuleBaseFactory.newRuleBase();
    ruleBase.addPackage(pkg);

    final StatefulSession session = ruleBase.newStatefulSession();

    new Thread(
            new Runnable() {
              public void run() {
                session.fireUntilHalt();
              }
            })
        .start();

    session.startProcess("com.sample.ruleflow", null);

    assertEquals(1, session.getProcessInstances().size());
    session.halt();

    final StatefulSession session2 = getSerialisedStatefulSession(session);

    new Thread(
            new Runnable() {
              public void run() {
                session2.fireUntilHalt();
              }
            })
        .start();

    Thread.sleep(400);

    assertEquals(0, session2.getProcessInstances().size());

    session2.halt();
  }
コード例 #21
0
  @Test
  public void testVariablePersistenceMarshallingStrategies() throws Exception {
    String process =
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
            + "<process xmlns=\"http://drools.org/drools-5.0/process\"\n"
            + "    xmlns:xs=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
            + "    xs:schemaLocation=\"http://drools.org/drools-5.0/process drools-processes-5.0.xsd\"\n"
            + "    type=\"RuleFlow\" name=\"ruleflow\" id=\"org.test.ruleflow\" package-name=\"org.test\" >\n"
            + "  <header>\n"
            + "    <variables>\n"
            + "      <variable name=\"myVariable\" >\n"
            + "        <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "        <value>OldValue</value>\n"
            + "      </variable>\n"
            + "      <variable name=\"myPerson\" >\n"
            + "        <type name=\"org.drools.core.process.core.datatype.impl.type.ObjectDataType\" className=\"org.jbpm.integrationtests.test.Person\"/>\n"
            + "      </variable>\n"
            + "    </variables>\n"
            + "  </header>\n"
            + "  <nodes>\n"
            + "    <start id=\"1\" name=\"Start\" />\n"
            + "    <workItem id=\"2\" name=\"Email\" >\n"
            + "      <work name=\"Report\" >\n"
            + "        <parameter name=\"Subject\" >\n"
            + "          <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "          <value>Mail</value>\n"
            + "        </parameter>\n"
            + "        <parameter name=\"Subject\" >\n"
            + "          <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "          <value>Mail</value>\n"
            + "        </parameter>\n"
            + "      </work>\n"
            + "    </workItem>\n"
            + "    <end id=\"3\" name=\"End\" />\n"
            + "  </nodes>\n"
            + "  <connections>\n"
            + "    <connection from=\"1\" to=\"2\"/>\n"
            + "    <connection from=\"2\" to=\"3\"/>\n"
            + "  </connections>\n"
            + "</process>";
    final PackageBuilder builder = new PackageBuilder();
    builder.addProcessFromXml(new StringReader(process));
    final Package pkg = builder.getPackage();

    final RuleBase ruleBase = RuleBaseFactory.newRuleBase();
    ruleBase.addPackage(pkg);

    StatefulSession session = ruleBase.newStatefulSession();
    TestWorkItemHandler handler = new TestWorkItemHandler();
    session.getWorkItemManager().registerWorkItemHandler("Report", handler);
    Map<String, Object> variables = new HashMap<String, Object>();
    variables.put("myVariable", "ThisIsMyValue");
    Person myPerson = new Person("Nikola Tesla", 156);
    variables.put("myPerson", myPerson);
    session.startProcess("org.test.ruleflow", variables);

    assertEquals(1, session.getProcessInstances().size());
    assertTrue(handler.getWorkItem() != null);

    session = getSerialisedStatefulSession(session);
    assertEquals(1, session.getProcessInstances().size());
    VariableScopeInstance variableScopeInstance =
        (VariableScopeInstance)
            ((ProcessInstance) session.getProcessInstances().iterator().next())
                .getContextInstance(VariableScope.VARIABLE_SCOPE);
    assertEquals("ThisIsMyValue", variableScopeInstance.getVariable("myVariable"));
    assertEquals(myPerson, variableScopeInstance.getVariable("myPerson"));

    session.getWorkItemManager().completeWorkItem(handler.getWorkItem().getId(), null);

    assertEquals(0, session.getProcessInstances().size());
  }
コード例 #22
0
  @Test
  public void test6() throws Exception {
    String process =
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
            + "<process xmlns=\"http://drools.org/drools-5.0/process\"\n"
            + "  xmlns:xs=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
            + "  xs:schemaLocation=\"http://drools.org/drools-5.0/process drools-processes-5.0.xsd\"\n"
            + "  type=\"RuleFlow\" name=\"ruleflow\" id=\"com.sample.ruleflow\" package-name=\"com.sample\" >\n"
            + "\n"
            + "    <header>\n"
            + "    </header>\n"
            + "\n"
            + "    <nodes>\n"
            + "      <start id=\"1\" name=\"Start\" />\n"
            + "      <timerNode id=\"4\" name=\"Timer\" delay=\"200\" />\n"
            + "      <end id=\"3\" name=\"End\" />\n"
            + "    </nodes>\n"
            + "\n"
            + "    <connections>\n"
            + "      <connection from=\"1\" to=\"4\" />\n"
            + "      <connection from=\"4\" to=\"3\" />\n"
            + "    </connections>\n"
            + "\n"
            + "</process>\n";
    final PackageBuilder builder = new PackageBuilder();
    builder.addProcessFromXml(new StringReader(process));
    final Package pkg = builder.getPackage();
    final RuleBase ruleBase = RuleBaseFactory.newRuleBase();
    ruleBase.addPackage(pkg);

    final StatefulSession session = ruleBase.newStatefulSession();

    new Thread(
            new Runnable() {
              public void run() {
                session.fireUntilHalt();
              }
            })
        .start();

    session.startProcess("com.sample.ruleflow", null);
    assertEquals(1, session.getProcessInstances().size());

    StatefulKnowledgeSession ksession =
        new StatefulKnowledgeSessionImpl((ReteooWorkingMemory) session);
    Marshaller marshaller = MarshallerFactory.newMarshaller(ksession.getKieBase());

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    marshaller.marshall(baos, ksession);
    byte[] b1 = baos.toByteArray();
    session.halt();
    session.dispose();
    Thread.sleep(400);

    ByteArrayInputStream bais = new ByteArrayInputStream(b1);
    final StatefulSession session2 =
        (StatefulSession) ((StatefulKnowledgeSessionImpl) marshaller.unmarshall(bais)).session;

    new Thread(
            new Runnable() {
              public void run() {
                session2.fireUntilHalt();
              }
            })
        .start();

    Thread.sleep(100);

    assertEquals(0, session2.getProcessInstances().size());
    session2.halt();
  }
コード例 #23
0
  @Test
  public void test4() throws Exception {
    String process =
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
            + "<process xmlns=\"http://drools.org/drools-5.0/process\"\n"
            + "  xmlns:xs=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
            + "  xs:schemaLocation=\"http://drools.org/drools-5.0/process drools-processes-5.0.xsd\"\n"
            + "  type=\"RuleFlow\" name=\"ruleflow\" id=\"com.sample.ruleflow\" package-name=\"com.sample\" >\n"
            + "\n"
            + "    <header>\n"
            + "      <variables>\n"
            + "        <variable name=\"list\" >\n"
            + "          <type name=\"org.drools.core.process.core.datatype.impl.type.ObjectDataType\" className=\"java.util.List\" />\n"
            + "        </variable>\n"
            + "      </variables>\n"
            + "    </header>\n"
            + "\n"
            + "    <nodes>\n"
            + "      <forEach id=\"4\" name=\"ForEach\" variableName=\"item\" collectionExpression=\"list\" >\n"
            + "        <nodes>\n"
            + "          <humanTask id=\"1\" name=\"Human Task\" >\n"
            + "            <work name=\"Human Task\" >\n"
            + "              <parameter name=\"Comment\" >\n"
            + "                <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "              </parameter>\n"
            + "              <parameter name=\"ActorId\" >\n"
            + "                <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "              </parameter>\n"
            + "              <parameter name=\"Priority\" >\n"
            + "                <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "              </parameter>\n"
            + "              <parameter name=\"TaskName\" >\n"
            + "                <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "                <value>Do something: #{item}</value>\n"
            + "              </parameter>\n"
            + "            </work>\n"
            + "          </humanTask>\n"
            + "          <humanTask id=\"2\" name=\"Human Task Again\" >\n"
            + "            <work name=\"Human Task\" >\n"
            + "              <parameter name=\"Comment\" >\n"
            + "                <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "              </parameter>\n"
            + "              <parameter name=\"ActorId\" >\n"
            + "                <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "              </parameter>\n"
            + "              <parameter name=\"Priority\" >\n"
            + "                <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "              </parameter>\n"
            + "              <parameter name=\"TaskName\" >\n"
            + "                <type name=\"org.drools.core.process.core.datatype.impl.type.StringDataType\" />\n"
            + "                <value>Do something else: #{item}</value>\n"
            + "              </parameter>\n"
            + "            </work>\n"
            + "          </humanTask>\n"
            + "        </nodes>\n"
            + "        <connections>\n"
            + "          <connection from=\"1\" to=\"2\" />\n"
            + "        </connections>\n"
            + "        <in-ports>\n"
            + "          <in-port type=\"DROOLS_DEFAULT\" nodeId=\"1\" nodeInType=\"DROOLS_DEFAULT\" />\n"
            + "        </in-ports>\n"
            + "        <out-ports>\n"
            + "          <out-port type=\"DROOLS_DEFAULT\" nodeId=\"2\" nodeOutType=\"DROOLS_DEFAULT\" />\n"
            + "        </out-ports>\n"
            + "      </forEach>\n"
            + "      <start id=\"1\" name=\"Start\" />\n"
            + "      <end id=\"3\" name=\"End\" />\n"
            + "    </nodes>\n"
            + "\n"
            + "    <connections>\n"
            + "      <connection from=\"1\" to=\"4\" />\n"
            + "      <connection from=\"4\" to=\"3\" />\n"
            + "    </connections>\n"
            + "\n"
            + "</process>\n";
    final PackageBuilder builder = new PackageBuilder();
    builder.addProcessFromXml(new StringReader(process));
    final Package pkg = builder.getPackage();
    final RuleBase ruleBase = RuleBaseFactory.newRuleBase();
    ruleBase.addPackage(pkg);

    StatefulSession session = ruleBase.newStatefulSession();

    TestListWorkItemHandler handler = new TestListWorkItemHandler();
    session.getWorkItemManager().registerWorkItemHandler("Human Task", handler);
    List<String> list = new ArrayList<String>();
    list.add("one");
    list.add("two");
    list.add("three");
    Map<String, Object> parameters = new HashMap<String, Object>();
    parameters.put("list", list);
    session.startProcess("com.sample.ruleflow", parameters);

    assertEquals(1, session.getProcessInstances().size());
    assertEquals(3, handler.getWorkItems().size());

    //        session = getSerialisedStatefulSession( session );
    //        session.getWorkItemManager().registerWorkItemHandler("Human Task", handler);

    List<WorkItem> workItems = new ArrayList<WorkItem>(handler.getWorkItems());
    handler.reset();
    for (WorkItem workItem : workItems) {
      session.getWorkItemManager().completeWorkItem(workItem.getId(), null);
    }
    assertEquals(1, session.getProcessInstances().size());
    assertEquals(3, handler.getWorkItems().size());

    session = getSerialisedStatefulSession(session);

    for (WorkItem workItem : handler.getWorkItems()) {
      session.getWorkItemManager().completeWorkItem(workItem.getId(), null);
    }
    assertEquals(0, session.getProcessInstances().size());
  }