private void checkPartitionedSinks(ObjectTypeNode otn) { if ( InitialFact.class.isAssignableFrom( ( (ClassObjectType) otn.getObjectType() ).getClassType() ) ) { return; } ObjectSinkPropagator sinkPropagator = otn.getObjectSinkPropagator(); ObjectSinkPropagator[] propagators = sinkPropagator instanceof CompositePartitionAwareObjectSinkAdapter ? ((CompositePartitionAwareObjectSinkAdapter) sinkPropagator).getPartitionedPropagators() : new ObjectSinkPropagator[] { sinkPropagator }; for (int i = 0; i < propagators.length; i++) { for (ObjectSink sink : propagators[i].getSinks()) { assertEquals( sink + " on " + sink.getPartitionId() + " is expcted to be on propagator " + i, i, sink.getPartitionId().getId() % propagators.length ); } } }
@Test public void test1() { StatefulKnowledgeSessionImpl ksession = (StatefulKnowledgeSessionImpl)kBase.newKieSession(); final ObjectTypeNode objectTypeNode = new ObjectTypeNode( 1, this.entryPoint, new ClassObjectType( State.class ), buildContext ); objectTypeNode.attach(buildContext); final MockObjectSink sink = new MockObjectSink(); objectTypeNode.addObjectSink( sink ); final State a = new State( "go" ); ksession.insert( a, true ); ksession.fireAllRules(); assertEquals( 1, sink.getAsserted().size() ); a.setState( "stop" ); }
/** * Tests ObjectTypeNodes are correctly added to the Rete object * * @throws Exception */ @Test public void testObjectTypeNodes() throws Exception { final Rete rete = kBase.getRete(); final ObjectTypeNode objectTypeNode = new ObjectTypeNode(1, this.entryPoint, new ClassObjectType(Object.class), buildContext); objectTypeNode.attach(buildContext); final ObjectTypeNode stringTypeNode = new ObjectTypeNode(2, this.entryPoint, new ClassObjectType(String.class), buildContext); stringTypeNode.attach(buildContext); final List<ObjectTypeNode> list = rete.getObjectTypeNodes(); // Check the ObjectTypeNodes are correctly added to Rete assertEquals(3, list.size()); assertTrue(list.contains(objectTypeNode)); assertTrue(list.contains(stringTypeNode)); }
private void initPathMemories() { pathMemories = new PathMemory[3]; NamedEntryPoint ep = (NamedEntryPoint)epManipulators[8].getEntryPoiny(); InternalWorkingMemory wm = ((NamedEntryPoint)ep).getInternalWorkingMemory(); ObjectTypeNode otn = ((NamedEntryPoint)ep).getEntryPointNode().getObjectTypeNodes().values().iterator().next(); AlphaNode alpha = (AlphaNode)otn.getObjectSinkPropagator().getSinks()[0]; ObjectSink[] sinks = alpha.getObjectSinkPropagator().getSinks(); for (int i = 0; i < sinks.length; i++) { BetaNode beta = (BetaNode)sinks[i]; RuleTerminalNode rtn = (RuleTerminalNode)beta.getSinkPropagator().getSinks()[0]; pathMemories[i] = ( PathMemory ) wm.getNodeMemory(rtn); } } }
public static Class<?> getNodeClass( ObjectTypeNode objectTypeNode ) { ObjectType objectType = objectTypeNode.getObjectType(); return objectType != null && objectType instanceof ClassObjectType ? ((ClassObjectType)objectType).getClassType() : null; }
@Test public void testAdd() { /* * create a RuleBase with a single ObjectTypeNode we attach a * MockObjectSink so we can detect assertions and retractions */ InternalKnowledgeBase kBase = (InternalKnowledgeBase) KnowledgeBaseFactory.newKnowledgeBase(); BuildContext context = new BuildContext(kBase); NodeFactory nFacotry = kBase.getConfiguration().getComponentFactory().getNodeFactoryService(); EntryPointNode entryPoint = context.getKnowledgeBase().getRete().getEntryPointNodes().values().iterator().next(); final ObjectTypeNode objectTypeNode = nFacotry.buildObjectTypeNode( 0, entryPoint, new ClassObjectType( Object.class ), context ); objectTypeNode.attach(context); final MockObjectSink sink = new MockObjectSink(); objectTypeNode.addObjectSink( sink ); kBase.newKieSession(); // objectTypeNode. }
context = pctxFactory.createPropagationContext(0, PropagationContext.Type.INSERTION, null, null, null); ObjectTypeNode otn = new ObjectTypeNode( 4, null, new ClassObjectType( String.class ), buildContext ); lian = new LeftInputAdapterNode(5, otn, buildContext );
LeftInputAdapterNode liaNode = ( LeftInputAdapterNode ) otnInit.getObjectSinkPropagator().getSinks()[0]; ObjectTypeNode otnCheese = getObjectTypeNode(kbase, "Cheese" ); assertEquals( 0, otnPerson.getOtnIdCounter() ); assertEquals( 0, otnCheese.getOtnIdCounter() ); wm.insert( new Person() ); wm.insert( new Cheese() ); wm.fireAllRules(); assertEquals( 5, otnPerson.getOtnIdCounter() ); assertEquals( 4, otnCheese.getOtnIdCounter() );
ObjectTypeNode otnCat = getObjectTypeNode(kbase, "Cat" ); assertEquals( 0, otnPerson.getOtnIdCounter() ); assertEquals( 0, otnCheese.getOtnIdCounter() ); assertEquals( 0, otnCat.getOtnIdCounter() ); wm.insert( new Person() ); wm.insert( new Cat("yyy") ); wm.fireAllRules(); assertEquals( 2, otnPerson.getOtnIdCounter() ); assertEquals( 4, otnCheese.getOtnIdCounter() ); assertEquals( 2, otnCat.getOtnIdCounter() );
AlphaNode alpha = (AlphaNode)otn.getObjectSinkPropagator().getSinks()[0]; BetaNode beta = (BetaNode)alpha.getObjectSinkPropagator().getSinks()[0]; BetaMemory memory = (BetaMemory) wm.getNodeMemory(beta);
public ObjectTypeNode getObjectTypeNode(KieBase kbase, String nodeName) { List<ObjectTypeNode> nodes = ((KnowledgeBaseImpl)kbase).getRete().getObjectTypeNodes(); for ( ObjectTypeNode n : nodes ) { if ( ((ClassObjectType)n.getObjectType()).getClassType().getSimpleName().equals( nodeName ) ) { return n; } } return null; }
final ObjectTypeNode objectTypeNode = new ObjectTypeNode( idGenerator.getNextId(), this.entryPoint, new ClassObjectType( String.class ), buildContext ); objectTypeNode.attach( buildContext );
context = pctxFactory.createPropagationContext(0, PropagationContext.Type.INSERTION, null, null, null); ObjectTypeNode otn = new ObjectTypeNode( 4, null, new ClassObjectType( String.class ), buildContext ); liaNode = new LeftInputAdapterNode( 5, otn, buildContext );
@Test public void testFromEPDontRequireLeftInput() { // DROOLS-1014 String drl = "rule R when\n" + " $s1 : String() from entry-point \"xxx\"\n" + "then\n" + "end\n"; KieBase kbase = new KieHelper().addContent( drl, ResourceType.DRL ) .build(); Rete rete = ( (KnowledgeBaseImpl) kbase ).getRete(); LeftInputAdapterNode liaNode = null; for ( ObjectTypeNode otn : rete.getObjectTypeNodes() ) { Class<?> otnType = ( (ClassObjectType) otn.getObjectType() ).getClassType(); if ( String.class == otnType ) { assertEquals( 1, otn.getObjectSinkPropagator().size() ); } else if ( InitialFact.class.isAssignableFrom( otnType ) ) { assertEquals( 0, otn.getObjectSinkPropagator().size() ); } else { fail("There shouldn't be other OTNs"); } } }
@Test public void testIsShadowed() { StatefulKnowledgeSessionImpl ksession = (StatefulKnowledgeSessionImpl)kBase.newKieSession(); // Create a Rete network with ObjectTypeNodes for List, Collection and ArrayList final Rete rete = kBase.getRete(); final ObjectTypeNode objectTypeNode = new ObjectTypeNode(1, this.entryPoint, new ClassObjectType(Cheese.class), buildContext); objectTypeNode.attach(buildContext); final MockObjectSink sink1 = new MockObjectSink(); objectTypeNode.addObjectSink(sink1); // There are no String ObjectTypeNodes, make sure its not propagated final Cheese cheese = new Cheese("brie", 15); final DefaultFactHandle h1 = new DefaultFactHandle(1, cheese); rete.assertObject(h1, pctxFactory.createPropagationContext(0, PropagationContext.Type.INSERTION, null, null, null), ksession); ksession.fireAllRules(); final Object[] results = (Object[]) sink1.getAsserted().get(0); }
@Test(timeout = 40000L) public void test() { StringBuilder sb = new StringBuilder( 400 ); sb.append( "global java.util.List list;\n" ); for (int i = 0; i < 10; i++) { sb.append( getRule( i, "" ) ); } KieBase kbase = new KieHelper().addContent( sb.toString(), ResourceType.DRL ) .build( MultithreadEvaluationOption.YES ); EntryPointNode epn = ((InternalKnowledgeBase) kbase).getRete().getEntryPointNode( EntryPointId.DEFAULT ); ObjectTypeNode otn = epn.getObjectTypeNodes().get( new ClassObjectType( Integer.class ) ); assertTrue( ( (CompositePartitionAwareObjectSinkAdapter) otn.getObjectSinkPropagator() ).isHashed() ); KieSession ksession = kbase.newKieSession(); assertTrue( ( (InternalWorkingMemory) ksession ).getAgenda().isParallelAgenda() ); List<Integer> list = new DebugList<Integer>(); ksession.setGlobal( "list", list ); for (int i = 0; i < 10; i++) { ksession.insert( i ); ksession.insert( "" + i ); } ksession.fireAllRules(); assertEquals(10, list.size()); }
public ObjectTypeNode getObjectTypeNode(KieBase kbase, Class<?> nodeClass) { List<ObjectTypeNode> nodes = ((KnowledgeBaseImpl)kbase).getRete().getObjectTypeNodes(); for ( ObjectTypeNode n : nodes ) { if ( ((ClassObjectType)n.getObjectType()).getClassType() == nodeClass ) { return n; } } return null; } }
rule3 = new RuleImpl( "rule3" ); ObjectTypeNode otn = new ObjectTypeNode( 3, null, new ClassObjectType( String.class ), buildContext ); liaNode = new LeftInputAdapterNode(4, otn, buildContext );
@Test public void testRtnNoConstraintsWithWatches() { String rule1 = "A() @watch(a)"; KieBase kbase = getKnowledgeBase(rule1); InternalWorkingMemory wm = ((InternalWorkingMemory)kbase.newKieSession()); ObjectTypeNode otn = getObjectTypeNode(kbase, "A" ); assertNotNull( otn ); Class classType = ((ClassObjectType) otn.getObjectType()).getClassType(); LeftInputAdapterNode liaNode = ( LeftInputAdapterNode ) otn.getObjectSinkPropagator().getSinks()[0]; List<String> sp = getSettableProperties(wm, otn); RuleTerminalNode rtNode = ( RuleTerminalNode ) liaNode.getSinkPropagator().getSinks()[0]; assertEquals( calculatePositiveMask(classType, list("a"), sp), rtNode.getDeclaredMask() ); assertEquals( calculatePositiveMask(classType, list("a"), sp), rtNode.getInferredMask() ); }
ObjectTypeNode objectTypeNode = new ObjectTypeNode(1, this.entryPoint, new ClassObjectType(List.class), buildContext); objectTypeNode.attach(buildContext); MockObjectSink sink = new MockObjectSink(); objectTypeNode.addObjectSink(sink); objectTypeNode = new ObjectTypeNode(1, this.entryPoint, new ClassObjectType(Collection.class), buildContext); objectTypeNode.attach(buildContext); sink = new MockObjectSink(); objectTypeNode.addObjectSink(sink); objectTypeNode = new ObjectTypeNode(1, this.entryPoint, new ClassObjectType(ArrayList.class), buildContext); objectTypeNode.attach(buildContext); sink = new MockObjectSink(); objectTypeNode.addObjectSink(sink);