org.junit.jupiter.api.function.ThrowingSupplier#org.kie.internal.utils.KieHelper源码实例Demo

protected KieSession getSessionFromString( String drlString, KieBaseConfiguration kbConf ) {
    KieHelper kieHelper = new KieHelper();
    kieHelper.addContent( drlString, ResourceType.DRL );

    Results res = kieHelper.verify();
    if ( res.hasMessages( Message.Level.ERROR ) ) {
        fail( res.getMessages( Message.Level.ERROR ).toString() );
    }

    if ( kbConf == null ) {
        kbConf = KieServices.Factory.get().newKieBaseConfiguration();
    }
    kbConf.setOption( EqualityBehaviorOption.EQUALITY );
    KieBase kieBase = kieHelper.build( kbConf );


    KieSessionConfiguration ksConf = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
    ((SessionConfiguration) ksConf).setBeliefSystemType( BeliefSystemType.DEFEASIBLE );
    return kieBase.newKieSession( ksConf, null );
}
 

@Test
public void testRTNodeWithConstraintsNoPropertySpecific() {
    String rule = "package org.drools.compiler.integrationtests\n" +
                  "import " + Person.class.getCanonicalName() + "\n" +
                  "rule r1\n" +
                  "when\n" +
                  "   Person( name == 'bobba')\n" +
                  "then\n" +
                  "end\n";
    
    KieBase kbase = new KieHelper(PropertySpecificOption.ALLOWED).addContent(rule, ResourceType.DRL).build();
    
    ObjectTypeNode otn = getObjectTypeNode(kbase, "Person" );
    assertNotNull( otn );

    AlphaNode alphaNode = ( AlphaNode ) otn.getObjectSinkPropagator().getSinks()[0];
    assertEquals( AllSetBitMask.get(), alphaNode.getDeclaredMask() );
    assertEquals( AllSetBitMask.get(), alphaNode.getInferredMask() );
    
    
    LeftInputAdapterNode liaNode = ( LeftInputAdapterNode ) alphaNode.getObjectSinkPropagator().getSinks()[0];
    
    RuleTerminalNode rtNode = ( RuleTerminalNode ) liaNode.getSinkPropagator().getSinks()[0];
    assertEquals( AllSetBitMask.get(), rtNode.getDeclaredMask() );
    assertEquals( AllSetBitMask.get(), rtNode.getInferredMask() );
}
 

@Test
public void testJittingEnum() {
    final String drl = "import " + AnEnum.class.getCanonicalName() + ";\n" +
            " rule R1 \n" +
            " when \n" +
            "    $enumFact: AnEnum(this == AnEnum.FIRST)\n" +
            " then \n" +
            " end ";

    final KieHelper kieHelper = new KieHelper();
    kieHelper.addContent( drl, ResourceType.DRL );
    final KieBase kieBase = kieHelper.build(ConstraintJittingThresholdOption.get(0));
    final KieSession kieSession = kieBase.newKieSession();

    kieSession.insert(AnEnum.FIRST);
    assertThat(kieSession.fireAllRules()).isEqualTo(1);
}
 

@Test
public void testMultipleParallelKieSessionsWithDeletes() throws InterruptedException, ExecutionException, TimeoutException {
    final int NUMBER_OF_PARALLEL_SESSIONS = 5;

    /* Create KIE base */
    StringBuilder sb = new StringBuilder(400);
    sb.append("global java.util.List list;\n");
    for (int i = 1; i < 11; i++) {
        sb.append(getRule(i, "delete( $i );\n"));
    }
    for (int i = 1; i < 11; i++) {
        sb.append(getNotRule(i));
    }
    KieBase kbase = new KieHelper().addContent(sb.toString(), ResourceType.DRL)
            .build(MultithreadEvaluationOption.YES);

    List<Callable<Void>> tasks = new ArrayList<>();
    for (int i = 0; i < NUMBER_OF_PARALLEL_SESSIONS; i++) {
        tasks.add(getMultipleParallelKieSessionsWithDeletesCallable(kbase));
    }

    /* Run tasks in parallel */
    runTasksInParallel(tasks);
}
 

@Test
public void testGenerics() throws Exception {
    // DROOLS-4939
    String drl =
            "package org.drools.compiler\n" +
                    "import java.util.List\n" +
                    "declare Node\n" +
                    "    values: List<String>\n" +
                    "end\n" +
                    "rule R1 when\n" +
                    "   $node: Node( values.get(0).length == 4 )\n" +
                    "then\n" +
                    "   System.out.println( $node );\n" +
                    "end";

    KieBase kbase = new KieHelper().addContent(drl, ResourceType.DRL).build();
    KieSession ksession = kbase.newKieSession();

    FactType nodeType = kbase.getFactType( "org.drools.compiler", "Node" );
    Object parent = nodeType.newInstance();
    nodeType.set( parent, "values", Arrays.asList("test") );
    ksession.insert( parent );

    int rules = ksession.fireAllRules();
    assertEquals( 1, rules );
}
 

@Test
public void testBetaNodeWithConstraintsNoPropertySpecific() {
    String rule = "package org.drools.compiler.integrationtests\n" +
                  "import " + Person.class.getCanonicalName() + "\n" +
                  "import " + Cheese.class.getCanonicalName() + "\n" +
                  "rule r1\n" +
                  "when\n" +
                  "   Person()\n" +
                  "   Cheese( type == 'brie' )\n" +
                  "then\n" +
                  "end\n";
    
    KieBase kbase = new KieHelper(PropertySpecificOption.ALLOWED).addContent(rule, ResourceType.DRL).build();
    
    ObjectTypeNode otn = getObjectTypeNode(kbase, "Cheese" );
    assertNotNull( otn );

    AlphaNode alphaNode = ( AlphaNode ) otn.getObjectSinkPropagator().getSinks()[0];
    assertEquals( AllSetBitMask.get(), alphaNode.getDeclaredMask() );
    assertEquals( AllSetBitMask.get(), alphaNode.getInferredMask() );
    
    BetaNode betaNode = ( BetaNode ) alphaNode.getObjectSinkPropagator().getSinks()[0];
    
    assertEquals( AllSetBitMask.get(), betaNode.getRightDeclaredMask() );
    assertEquals( AllSetBitMask.get(), betaNode.getRightInferredMask() );
}
 

@Test
public void testModifySubclassOverWindow() {
    // DROOLS-1501
    String drl = "declare Number @role( event ) end\n" +
                 "declare Integer @role( event ) end\n" +
                 "\n" +
                 "rule R1 no-loop when\n" +
                 "    $i: Integer()\n" +
                 "then\n" +
                 "    update($i);\n" +
                 "end\n" +
                 "rule R2 when\n" +
                 "    $n: Number() over window:length(1)\n" +
                 "then\n" +
                 "end";

    KieSession ksession = new KieHelper().addContent( drl, ResourceType.DRL )
                                         .build( EventProcessingOption.STREAM )
                                         .newKieSession();
    ksession.insert(1);
    ksession.fireAllRules();
}
 

@ParameterizedMarshallerTest
public void testFromWithFireAfterSerialization(Environment env) throws Exception {
    String str =
            "import java.util.Collection\n" +
                    "rule R1 when\n" +
                    "    String() from [ \"x\", \"y\", \"z\" ]\n" +
                    "then\n" +
                    "end\n";

    KieBase kbase = new KieHelper().addContent(str, ResourceType.DRL).build();
    KieSession ksession = null;
    try {
        ksession = kbase.newKieSession(null, env);

        ksession = SerializationHelper.getSerialisedStatefulKnowledgeSession(ksession, true);

        assertEquals(3, ksession.fireAllRules());
    } finally {
        if (ksession != null) {
            ksession.dispose();
        }
    }
}
 

@Test
public void testQueryWithIncompatibleArgs() {
    String drl = "global java.util.List list; " +
                 "" +
                 "query foo( String $s, String $s, String $s ) end " +
                 "" +
                 "rule React \n" +
                 "when\n" +
                 "  $i : Integer() " +
                 "  foo( $i, $x, $i ; ) " +
                 "then\n" +
                 "end";

    KieHelper helper = new KieHelper();
    helper.addContent( drl, ResourceType.DRL );
    Results results = helper.verify();
    assertTrue( results.hasMessages( Message.Level.ERROR ) );
    assertEquals( 2, results.getMessages( Message.Level.ERROR ).size() );
}
 

@Test
public void testRTNodeNoConstraintsNoPropertySpecific() {
    String rule = "package org.drools.compiler.integrationtests\n" +
                  "import " + Person.class.getCanonicalName() + "\n" +
                  "rule r1\n" +
                  "when\n" +
                  "   Person()\n" +
                  "then\n" +
                  "end\n";
    
    KieBase kbase = new KieHelper(PropertySpecificOption.ALLOWED).addContent(rule, ResourceType.DRL).build();
    
    ObjectTypeNode otn = getObjectTypeNode(kbase, "Person" );
    assertNotNull( otn );

    LeftInputAdapterNode liaNode = ( LeftInputAdapterNode ) otn.getObjectSinkPropagator().getSinks()[0];
    
    RuleTerminalNode rtNode = ( RuleTerminalNode ) liaNode.getSinkPropagator().getSinks()[0];
    assertEquals( AllSetBitMask.get(), rtNode.getDeclaredMask() );
    assertEquals( AllSetBitMask.get(), rtNode.getInferredMask() );
}
 

@Test
public void testRedeclareWithInterfaceExtensionAndOverride() {
    final String s1 = "package test;\n" +

                      "declare trait " + Ext.class.getCanonicalName() + " extends " + Base.class.getCanonicalName() + " " +
                      " fld : String " +
                      "end " +

                      "declare trait " + Base.class.getCanonicalName() + " " +
                      "end " +
                      "";

    KieHelper kh = new KieHelper();
    kh.addContent( s1, ResourceType.DRL );

    assertEquals( 0, kh.verify().getMessages( Message.Level.ERROR ).size() );
}
 

@Test
public void testModifyWithGetter() {
    final String rule1 =
            "package foo.bar\n" +
            "import " + Person.class.getName() + "\n" +
            "declare Person @propertyReactive end\n" +
            "rule x\n" +
            "    when\n" +
            "       $p : Person( address != null ) @watch(!address) \n" +
            "    then\n" +
            "       modify($p){getAddress().setStreet(\"foo\");}\n" +
            "end";

    final KieHelper helper = new KieHelper();
    helper.addContent(rule1, ResourceType.DRL);
    final KieSession ksession = helper.build().newKieSession();

    final Person p = new Person();
    p.setAddress(new Address());
    ksession.insert(p);

    final int fired = ksession.fireAllRules(10);

    assertEquals(1, fired);
    assertEquals("foo", p.getAddress().getStreet());
}
 

@Test
public void testQueryFromCode() {
    final String drl =
            "import org.drools.compiler.oopath.model.Thing;\n" +
                    "query isContainedIn( Thing $x, Thing $y )\n" +
                    "    $y := /$x/children\n" +
                    "or\n" +
                    "    ( $z := /$x/children and isContainedIn( $z, $y; ) )\n" +
                    "end\n";

    final Thing smartphone = new Thing("smartphone");
    final List<String> itemList = Arrays.asList(new String[] { "display", "keyboard", "processor" });
    itemList.stream().map(item -> new Thing(item)).forEach((thing) -> smartphone.addChild(thing));

    final KieSession ksession = new KieHelper().addContent( drl, ResourceType.DRL )
            .build()
            .newKieSession();
    ksession.insert(smartphone);

    final QueryResults queryResults = ksession.getQueryResults("isContainedIn", new Object[] { smartphone, Variable.v });
    final List<String> resultList = StreamSupport.stream(queryResults.spliterator(), false)
            .map(row -> ((Thing) row.get("$y")).getName()).collect(Collectors.toList());
    assertThat(resultList).as("Query does not contain all items").containsAll(itemList);

    ksession.dispose();
}
 

@Test
public void testUpdateOnNonExistingProperty() {
    // DROOLS-2170
    final String str1 =
            "import " + Klass.class.getCanonicalName() + "\n" +
            "rule R when\n" +
            "  Klass( b == 2 )\n" +
            "then\n" +
            "end\n";

    final KieSession ksession = new KieHelper().addContent( str1, ResourceType.DRL )
            .build()
            .newKieSession();

    final Klass bean = new Klass( 1, 2, 3, 4, 5, 6 );
    final FactHandle fh = ksession.insert( bean );
    ksession.fireAllRules();

    try {
        ksession.update( fh, bean, "z" );
        fail("Trying to update not existing property must fail");
    } catch (Exception e) {
        assertTrue( e.getMessage().contains( Klass.class.getName() ) );
    }
}
 

@Test
public void testPRAfterAccumulate() {
    // DROOLS-2427
    final String str1 =
            "import " + Order.class.getCanonicalName() + "\n" +
            "import " + OrderLine.class.getCanonicalName() + "\n" +
            "rule R when\n" +
            "        $o: Order($lines: orderLines)\n" +
            "        Number(intValue >= 15) from accumulate(\n" +
            "            OrderLine($q: quantity) from $lines\n" +
            "            , sum($q)\n" +
            "        )\n" +
            "    then\n" +
            "        modify($o) { setPrice(10) }\n" +
            "end\n";

    final KieSession ksession = new KieHelper().addContent( str1, ResourceType.DRL )
            .build()
            .newKieSession();

    Order order = new Order( Arrays.asList(new OrderLine( 9 ), new OrderLine( 8 )), 12 );
    ksession.insert( order );
    ksession.fireAllRules();

    assertEquals( 10, order.getPrice() );
}
 

@Test
public void testQueryWithSyntaxError() {
    String drl = "global java.util.List list; " +
                 "" +
                 "query foo( Integer $i ) end " +
                 "" +
                 "rule React \n" +
                 "when\n" +
                 "  $i : Integer() " +
                 "  foo( $i ) " +   // missing ";" should result in 1 compilation error
                 "then\n" +
                 "end";

    KieHelper helper = new KieHelper();
    helper.addContent( drl, ResourceType.DRL );
    Results results = helper.verify();
    assertTrue( results.hasMessages( Message.Level.ERROR ) );
    assertEquals( 1, results.getMessages( Message.Level.ERROR ).size() );
}
 

public static KieSession createKieSessionFromDRL(String drl) throws Exception{
    KieHelper kieHelper = new KieHelper();
    kieHelper.addContent(drl, ResourceType.DRL);
    Results results = kieHelper.verify();
    if (results.hasMessages(Message.Level.WARNING, Message.Level.ERROR)) {
        List<Message> messages = results.getMessages(Message.Level.WARNING, Message.Level.ERROR);
        for (Message message : messages) {
            System.out.println("Error: "+message.getText());
        }
        // throw new IllegalStateException("Compilation errors were found. Check the logs.");
    }
    return kieHelper.build().newKieSession();
}
 

@BeforeEach
public void setup() {
    this.kieBase = new KieHelper().build();
    // create several KieSessions
    this.kieBase.newKieSession();
    this.kieBase.newKieSession();
    this.kieBase.newKieSession();
}
 

@Test
public void testOOPathOnGraphWithReactiveContentModificationInSubgraph() {
    String drl =
            "import org.drools.compiler.oopath.graph.*;\n" +
            "import " + Library.class.getCanonicalName() + ";\n" +
            "import " + Book.class.getCanonicalName() + ";\n" +
            "import " + Person.class.getCanonicalName() + ";\n" +
            "global java.util.List list\n" +
            "\n" +
            "rule R when\n" +
            "  Vertex( it instanceof Library, $v : /outVs/outVs[ /it#Person[ age > 25 ] ] )\n" +
            "then\n" +
            "  list.add( ((Person)$v.getIt()).getName() );\n" +
            "end\n";

    KieSession ksession = new KieHelper().addContent( drl, ResourceType.DRL )
                                         .build()
                                         .newKieSession();

    List<String> list = new ArrayList<String>();
    ksession.setGlobal( "list", list );

    Vertex<Library> library = getGraph();
    ksession.insert( library );
    ksession.fireAllRules();

    assertEquals( 1, list.size() );
    assertTrue( list.contains( "Mario" ) );
    list.clear();

    Person raoul = (Person)library.getOutVs().get(0).getOutVs().get(0).getIt();
    assertEquals( "Raoul", raoul.getName() );
    raoul.setAge( raoul.getAge() + 1 );

    ksession.fireAllRules();
    assertEquals( 1, list.size() );
    assertTrue( list.contains( "Raoul" ) );
}
 

@Test
public void testAccBigDecimal() {
    // DROOLS-4896
    String rule =
            "package com.sample.rules\n" +
            "import java.math.BigDecimal;\n" +
            "import " + BigDecimalFact.class.getCanonicalName() + "\n" +
            "rule R when\n" +
            "        accumulate( BigDecimalFact( $bdVal: bdVal), $minVal : min($bdVal))\n" +
            "        accumulate( BigDecimalFact( $bdVal2: bdVal, $bdVal2 > $minVal), $minVal2 : min($bdVal2))\n" +
            "\n" +
            "        \n" +
            "        $minFact: BigDecimalFact( bdVal == new BigDecimal($minVal.intValue()))\n" +
            "        $minFact2: BigDecimalFact( bdVal == new BigDecimal($minVal2.intValue()))\n" +
            "\n" +
            "then\n" +
            "    BigDecimal $difference = new BigDecimal($minVal2.intValue() - $minVal.intValue());\n" +
            "    $minFact2.setBdDiff($difference);\n" +
            "    update($minFact2);\n" +
            "    retract($minFact);\n" +
            "end\n";

    KieBase kbase = new KieHelper(PropertySpecificOption.ALLOWED).addContent(rule, ResourceType.DRL).build();
    KieSession kSession = kbase.newKieSession();

    final int NUM = 5;

    for (int i = 0; i < NUM; i++) {
        BigDecimalFact fact = new BigDecimalFact(100 + i*i*10);
        kSession.insert(fact);
    }

    assertEquals(NUM-1, kSession.fireAllRules());
}
 

@Test
public void testReactiveMap() {
    final String drl =
            "import org.drools.compiler.oopath.model.*;\n" +
                    "global java.util.List list\n" +
                    "\n" +
                    "rule R when\n" +
                    "  Man( $bodyMeasurement: /wife/bodyMeasurementsMap/entrySet )\n" +
                    "then\n" +
                    "  list.add( $bodyMeasurement.getValue() );\n" +
                    "end\n";

    final KieSession ksession = new KieHelper().addContent( drl, ResourceType.DRL )
            .build()
            .newKieSession();

    final List<Integer> list = new ArrayList<>();
    ksession.setGlobal("list", list);

    final Man bob = new Man("Bob", 40);
    final Woman alice = new Woman("Alice", 38);
    alice.putBodyMeasurement(CHEST, 80);
    bob.setWife(alice);

    ksession.insert(bob);
    ksession.fireAllRules();
    assertThat(list).containsExactlyInAnyOrder(80);

    list.clear();
    alice.putBodyMeasurement(RIGHT_FOREARM, 38);
    ksession.fireAllRules();
    assertThat(list).containsExactlyInAnyOrder(38, 80);
}
 

@Test
public void testStagedLeftTupleLeak() throws Exception {
    // BZ-1058874
    String str =
            "rule R1 when\n" +
            "    String( this == \"this\" )\n" +
            "    String( this == \"that\" )\n" +
            "then\n" +
            "end\n";

    KieBase kbase = new KieHelper().addContent( str, ResourceType.DRL ).build();
    KieSession ksession = kbase.newKieSession();
    ksession.fireAllRules();

    for ( int i = 0; i < 10; i++ ) {
        FactHandle fh = ksession.insert( "this" );
        ksession.fireAllRules();
        ksession.delete( fh );
        ksession.fireAllRules();
    }

    Rete rete = ( (KnowledgeBaseImpl) kbase ).getRete();
    LeftInputAdapterNode liaNode = null;
    for ( ObjectTypeNode otn : rete.getObjectTypeNodes() ) {
        if ( String.class == otn.getObjectType().getValueType().getClassType() ) {
            AlphaNode alphaNode = (AlphaNode) otn.getObjectSinkPropagator().getSinks()[0];
            liaNode = (LeftInputAdapterNode) alphaNode.getObjectSinkPropagator().getSinks()[0];
            break;
        }
    }

    assertNotNull( liaNode );
    InternalWorkingMemory wm = (InternalWorkingMemory) ksession;
    LeftInputAdapterNode.LiaNodeMemory memory = (LeftInputAdapterNode.LiaNodeMemory) wm.getNodeMemory( liaNode );
    TupleSets<LeftTuple> stagedLeftTuples = memory.getSegmentMemory().getStagedLeftTuples();
    assertNull( stagedLeftTuples.getDeleteFirst() );
    assertNull( stagedLeftTuples.getInsertFirst() );
}
 

@Test
public void testForallAfterOr() throws Exception {
    // DROOLS-2710
    String str =
            "package redhat\n" +
            "declare Fact\n" +
            "    integer : int\n" +
            "    string1 : String\n" +
            "    string2 : String\n" +
            "end\n" +
            "rule \"Rule\"\n" +
            "when\n" +
            "Fact(string2 == \"Y\")\n" +
            "(\n" +
            "    exists (Fact(integer == 42)) or\n" +
            "    Fact(integer == 43)\n" +
            ")\n" +
            "forall (Fact(string1 == \"X\"))\n" +
            "then\n" +
            "end";

    KieBase kieBase = new KieHelper().addContent( str, ResourceType.DRL ).build();
    KieSession kieSession = kieBase.newKieSession();

    FactType factType = kieBase.getFactType("redhat", "Fact");

    Object fact = factType.newInstance();
    factType.set(fact, "string1", "X");
    factType.set(fact, "string2", "Y");
    factType.set(fact, "integer", 42);

    kieSession.insert(fact);

    int n = kieSession.fireAllRules();
    assertEquals(1, n);
}
 

@Test
public void testAlpha() {
    String drl = "import " + A.class.getCanonicalName() + "\n" +
                 "declare A @role( event ) @expires(11ms) end\n" +
                 "global java.util.concurrent.atomic.AtomicInteger counter;\n" +
                 "rule R0 when\n" +
                 "  $a: A( $Aid: id > 0 )\n" +
                 "then\n" +
                 "  System.out.println(\"[\" + $a + \"]\");" +
                 "  counter.incrementAndGet();\n" +
                 "end";

    KieSessionConfiguration sessionConfig = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
    sessionConfig.setOption( ClockTypeOption.get( ClockType.PSEUDO_CLOCK.getId() ) );

    KieHelper helper = new KieHelper();
    helper.addContent( drl, ResourceType.DRL );
    KieBase kbase = helper.build( EventProcessingOption.STREAM );
    KieSession ksession = kbase.newKieSession( sessionConfig, null );

    PseudoClockScheduler sessionClock = ksession.getSessionClock();

    AtomicInteger counter = new AtomicInteger( 0 );
    ksession.setGlobal( "counter", counter );

    ksession.insert( new A(1) );

    sessionClock.advanceTime( 10, TimeUnit.MILLISECONDS );
    ksession.insert( new A(2) );

    sessionClock.advanceTime( 10, TimeUnit.MILLISECONDS );
    ksession.fireAllRules();
    assertEquals(2, counter.get());
}
 

@Test
public void testRedeclareClassAsTrait() {
    final String s1 = "package test; " +
                      "global java.util.List list; " +

                      "declare trait " + SomeClass.class.getCanonicalName() + " end ";

    KieHelper kh = new KieHelper();
    kh.addContent( s1, ResourceType.DRL );

    assertEquals( 1, kh.verify().getMessages( Message.Level.ERROR ).size() );
}
 

@Test
public void testBindListWithConstraint() {
    final String drl =
            "import org.drools.compiler.oopath.model.*;\n" +
                    "global java.util.List list\n" +
                    "\n" +
                    "rule R when\n" +
                    "  Man( $toys: /wife/children[age > 10].toys )\n" +
                    "then\n" +
                    "  list.add( $toys.size() );\n" +
                    "end\n";

    final KieSession ksession = new KieHelper().addContent( drl, ResourceType.DRL )
            .build()
            .newKieSession();

    final List<Integer> list = new ArrayList<>();
    ksession.setGlobal( "list", list );

    final Woman alice = new Woman( "Alice", 38 );
    final Man bob = new Man( "Bob", 40 );
    bob.setWife( alice );

    final Child charlie = new Child( "Charles", 12 );
    final Child debbie = new Child( "Debbie", 8 );
    alice.addChild( charlie );
    alice.addChild( debbie );

    charlie.addToy( new Toy( "car" ) );
    charlie.addToy( new Toy( "ball" ) );
    debbie.addToy( new Toy( "doll" ) );

    ksession.insert( bob );
    ksession.fireAllRules();

    assertThat(list).containsExactlyInAnyOrder(2);
}
 

public void updateConditions(String expiration, Collection<FullTrigger> activeTriggers) {
    expression = new Expression(expiration, activeTriggers);
    log.debugf("Rules: \n  %s", expression);
    stop();
    KieBaseConfiguration kieBaseConfiguration = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
    kieBaseConfiguration.setOption( EventProcessingOption.STREAM );
    KieBase kieBase = new KieHelper().addContent(expression.getDrl(), ResourceType.DRL).build(kieBaseConfiguration);
    KieSessionConfiguration kieSessionConf = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
    kieSessionConf.setOption( ClockTypeOption.get( "realtime" ) );

    kieSession = kieBase.newKieSession(kieSessionConf, null);
    results = new ArrayList<>();
    kieSession.setGlobal("results", this);
    kieSession.setGlobal("log", log);
    if (log.isDebugEnabled()) {
        kieSession.addEventListener(new CepAgendaEventListener());
        kieSession.addEventListener(new CepRuleRuntimeEventListener());
    }
    log.debugf("Clock time [%s] ", kieSession.getSessionClock().getCurrentTime());

    kieSession.getKieBase().getKiePackages().stream().forEach(p -> log.debugf("Rules: %s", p.getRules()));

    executor.submit(() -> {
        log.info("Starting fireUntilHalt()");
        kieSession.fireUntilHalt();
        log.info("Stopping fireUntilHalt()");
    });
}
 

@Test
public void testInheritFromClassWithDefaults() throws Exception {

    // car is a java class with attributes
    // brand (default ferrari)
    // expensive (default true)
    String s1 = "package org.drools.compiler;\n" +
            "global java.util.List list;\n" +
            "declare Car end\n" +
            "\n" +
            "declare MyCar extends Car \n" +
            " miles : int\n" +
            "end\n" +
            "\n" +
            "rule \"Init\"\n" +
            "when\n" +
            "then\n" +
            "  MyCar c = new MyCar();\n" +
            "  c.setMiles( 100 );" +
            "  insert( c );\n" +
            "end\n" +
            "rule \"Match\"\n" +
            "when\n" +
            "  MyCar( brand == \"ferrari\", expensive == true, $miles : miles ) " +
            "then\n" +
            "  list.add( $miles );\n" +
            "end";

    KieSession kSession = new KieHelper().addContent( s1, ResourceType.DRL )
                                         .build().newKieSession();

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

    kSession.fireAllRules();
    assertEquals( 1, list.size() );
    assertTrue( list.contains( 100 ) );

}
 

@Test
public void testQueryInSubnetwork() {
    // DROOLS-1386
    String str = "query myquery(Integer $i)\n" +
                 "   $i := Integer()\n" +
                 "end\n" +
                 "\n" +
                 "rule R when\n" +
                 "   String()\n" +
                 "   accumulate (myquery($i;);\n" +
                 "      $result_count : count(1)\n" +
                 "   )\n" +
                 "   eval($result_count > 0)\n" +
                 "then\n" +
                 "end\n\n";

    KieSession ksession = new KieHelper().addContent( str, ResourceType.DRL ).build().newKieSession();

    FactHandle iFH = ksession.insert( 1 );
    FactHandle sFH = ksession.insert( "" );

    ksession.fireAllRules();

    ksession.update( iFH, 1 );
    ksession.delete( sFH );

    ksession.fireAllRules();
}
 

@Test
public void testOOPathOnGraph() {
    String drl =
            "import org.drools.compiler.oopath.graph.*;\n" +
            "import " + Library.class.getCanonicalName() + ";\n" +
            "import " + Book.class.getCanonicalName() + ";\n" +
            "import " + Person.class.getCanonicalName() + ";\n" +
            "global java.util.List list\n" +
            "\n" +
            "rule R when\n" +
            "  Vertex( it instanceof Library, $a : /outVs/outVs/it#Person[ age > 40 ] )\n" +
            "then\n" +
            "  list.add( $a.getName() );\n" +
            "end\n";

    KieSession ksession = new KieHelper().addContent( drl, ResourceType.DRL )
                                         .build()
                                         .newKieSession();

    List<String> list = new ArrayList<String>();
    ksession.setGlobal( "list", list );

    Vertex<Library> library = getGraph();
    ksession.insert( library );
    ksession.fireAllRules();

    assertEquals( 1, list.size() );
    assertTrue( list.contains( "Mario" ) );
    list.clear();

    Vertex<?> book = library.getOutVs().get(0);
    Vertex<Person> alan = new Vertex<Person>( new Person( "Alan", 53 ) );
    book.connectTo( alan );

    ksession.fireAllRules();
    assertEquals( 1, list.size() );
    assertTrue( list.contains( "Alan" ) );
}