agendatest.java

drools 一个开放源码的规则引擎

    }

    public void testFocusStack() throws ConsequenceException
    {
        RuleBase ruleBase = new RuleBaseImpl( new Rete() );

        WorkingMemoryImpl workingMemory = (WorkingMemoryImpl) ruleBase.newWorkingMemory();

        final Agenda agenda = workingMemory.getAgenda();

        /* create the moduels */
        ModuleImpl module1 = new ModuleImpl( "module1",
                                             ruleBase.getConflictResolver() );
        agenda.addModule( module1 );

        ModuleImpl module2 = new ModuleImpl( "module2",
                                             ruleBase.getConflictResolver() );
        agenda.addModule( module2 );

        ModuleImpl module3 = new ModuleImpl( "module3",
                                             ruleBase.getConflictResolver() );
        agenda.addModule( module3 );

        /* create the consequence */
        Consequence consequence = new Consequence() {
            public void invoke(Activation activation)
            {
                // do nothing
            }
        };

        ReteTuple tuple = new ReteTuple( 0,
                                         new FactHandleImpl( 1 ),
                                         workingMemory );

        /* create a rule for each module */
        Rule rule0 = new Rule( "test-rule0" );
        rule0.setConsequence( consequence );
        PropagationContext context0 = new PropagationContextImpl( PropagationContext.ASSERTION,
                                                              rule0,
                                                              new AgendaItem( tuple,
                                                                              initContext,
                                                                              rule0 ) );

        Rule rule1 = new Rule( "test-rule1",
                               "module1" );
        rule1.setConsequence( consequence );
        PropagationContext context1 = new PropagationContextImpl( PropagationContext.ASSERTION,
                                                              rule1,
                                                              new AgendaItem( tuple,
                                                                              initContext,
                                                                              rule0 ) );

        Rule rule2 = new Rule( "test-rule2",
                               "module2" );
        rule2.setConsequence( consequence );
        PropagationContext context2 = new PropagationContextImpl( PropagationContext.ASSERTION,
                                                              rule2,
                                                              new AgendaItem( tuple,
                                                                              initContext,
                                                                              rule0 ) );

        Rule rule3 = new Rule( "test-rule3",
                               "module3" );
        rule3.setConsequence( consequence );
        PropagationContext context3 = new PropagationContextImpl( PropagationContext.ASSERTION,
                                                              rule3,
                                                              new AgendaItem( tuple,
                                                                              initContext,
                                                                              rule0 ) );

        /* focus at this point is MAIN */
        assertEquals( 0,
                      agenda.focusSize() );

        agenda.addToAgenda( tuple,
                            context0,
                            rule0 );

        /* check focus is main */
        ModuleImpl main = (ModuleImpl) agenda.getModule( Module.MAIN );
        assertEquals( agenda.getFocus(),
                      main );
        /* check main got the tuple */
        assertEquals( 1,
                      agenda.focusSize() );

        agenda.addToAgenda( tuple,
                            context2,
                            rule2 );
        /* main is still focus and this tuple went to module 2 */
        assertEquals( 1,
                      agenda.focusSize() );
        /* check module2 still got the tuple */
        assertEquals( 1,
                      module2.getActivationQueue().size() );

        /* make sure total agenda size reflects this */
        assertEquals( 2,
                      agenda.totalAgendaSize() );

        /* put another one on module 2 */
        agenda.addToAgenda( tuple,
                            context2,
                            rule2 );

        /* main is still focus so shouldn't have increased */
        assertEquals( 1,
                      agenda.focusSize() );

        /* check module2 still got the tuple */
        assertEquals( 2,
                      module2.getActivationQueue().size() );

        /* make sure total agenda size reflects this */
        assertEquals( 3,
                      agenda.totalAgendaSize() );

        /* set the focus to module1, note module1 has no activations */
        agenda.setFocus( "module1" );
        /* add module2 onto the focus stack */
        agenda.setFocus( "module2" );
        /* finally add module3 to the top of the focus stack */
        agenda.setFocus( "module3" );

        /* module3, the current focus, has no activations */
        assertEquals( 0,
                      agenda.focusSize() );

        /* add to module 3 */
        agenda.addToAgenda( tuple,
                            context3,
                            rule3 );
        assertEquals( 1,
                      agenda.focusSize() );

        agenda.addToAgenda( tuple,
                            context3,
                            rule3 );

        /* module3 now has 2 activations */
        assertEquals( 2,
                      agenda.focusSize() );
        /* check totalAgendaSize still works */
        assertEquals( 5,
                      agenda.totalAgendaSize() );

        /* ok now lets check that stacks work with fireNextItem */
        agenda.fireNextItem( null );

        /* module3 should still be the current module */
        assertEquals( agenda.getFocus(),
                      module3 );
        /* module3 has gone from 2 to one activations */
        assertEquals( 1,
                      agenda.focusSize() );
        /* check totalAgendaSize has reduced too */
        assertEquals( 4,
                      agenda.totalAgendaSize() );

        /* now repeat the process */
        agenda.fireNextItem( null );

        /* focus is still module3, but now its empty */
        assertEquals( agenda.getFocus(),
                      module3 );
        assertEquals( 0,
                      agenda.focusSize() );
        assertEquals( 3,
                      agenda.totalAgendaSize() );

        /* repeat fire again */
        agenda.fireNextItem( null );

        /*
         * module3 is empty so it should be popped from the stack making module2 the current module
         */
        assertEquals( agenda.getFocus(),
                      module2 );
        /* module2 had 2 activations, now it only has 1 */
        assertEquals( 1,
                      agenda.focusSize() );
        assertEquals( 2,
                      agenda.totalAgendaSize() );

        /* repeat fire again */
        agenda.fireNextItem( null );

        assertEquals( agenda.getFocus(),
                      module2 );
        assertEquals( 0,
                      agenda.focusSize() );
        assertEquals( 1,
                      agenda.totalAgendaSize() );

        /*
         * this last fire is more interesting as it demonstrates that module1 on the stack before module2 gets skipped as it has no activations
         */
        agenda.fireNextItem( null );

        assertEquals( agenda.getFocus(),
                      main );
        assertEquals( 0,
                      agenda.focusSize() );
        assertEquals( 0,
                      agenda.totalAgendaSize() );

    }
    
    public void testAutoFocus() throws ConsequenceException
    {
        RuleBase ruleBase = new RuleBaseImpl( new Rete() );

        WorkingMemoryImpl workingMemory = (WorkingMemoryImpl) ruleBase.newWorkingMemory();

        final Agenda agenda = workingMemory.getAgenda();

        /* create the module */
        ModuleImpl module = new ModuleImpl( "module",
                                             ruleBase.getConflictResolver() );
        agenda.addModule( module );  

        /* create the consequence */
        Consequence consequence = new Consequence() {
            public void invoke(Activation activation)
            {
                // do nothing
            }
        };

        ReteTuple tuple = new ReteTuple( 0,
                                         new FactHandleImpl( 1 ),
                                         workingMemory );

        /* create a rule for the module */
        Rule rule = new Rule( "test-rule",
                              "module" );
        rule.setConsequence( consequence );
        PropagationContext context = new PropagationContextImpl( PropagationContext.ASSERTION,
                                                                  rule,
                                                                  new AgendaItem( tuple,
                                                                                  initContext,
                                                                                  rule   ) );
          
        /* 
         * first test that autoFocus=false works.
         * Here the rule should not fire as its module does not have focus.
         */
        rule.setAutoFocus( false );
        
        agenda.addToAgenda( tuple,
                            context,
                            rule );                   
        
        /* check activation as added to the module */
        assertEquals( 1,
                      module.getActivationQueue().size() );  
        /* fire next item, module should not fire as its not on the focus stack and thus
         * should retain its sinle activation
         */
        agenda.fireNextItem( null );
        assertEquals( 1,
                      module.getActivationQueue().size() );  
        
        /* Clear the agenda we we can test again */
        agenda.clearAgenda();        
        assertEquals( 0,
                      module.getActivationQueue().size() );          
        
        /* 
         * Now test that autoFocus=true works.
         * Here the rule should fire as its module gets the focus when the activation 
         * is created.
         */
        rule.setAutoFocus( true );        
        
        agenda.addToAgenda( tuple,
                            context,
                            rule ); 

        assertEquals( 1,
                      module.getActivationQueue().size() );             
        agenda.fireNextItem( null );               
        assertEquals( 0,
                      module.getActivationQueue().size() );        
    }
}