ortest.java

jboss规则引擎

package org.drools.rule;

/*
 * Copyright 2005 JBoss Inc
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;

import junit.framework.TestCase;

import org.drools.WorkingMemory;
import org.drools.base.ClassFieldExtractor;
import org.drools.base.ClassObjectType;
import org.drools.base.EvaluatorFactory;
import org.drools.examples.waltz.Edge;
import org.drools.examples.waltz.Stage;
import org.drools.spi.Consequence;
import org.drools.spi.ConsequenceException;
import org.drools.spi.Evaluator;
import org.drools.spi.FieldConstraint;
import org.drools.spi.FieldExtractor;
import org.drools.spi.FieldValue;
import org.drools.spi.KnowledgeHelper;
import org.drools.spi.MockField;
import org.drools.spi.Tuple;

/**
 * This test demonstrate the following failures:
 * 1. Or constraint to produce matches when Or constraint is specified at the beging. 
 * I suspect it has something to do with regular columns having higher indexes
 * 
 * 2. Resolve an object that has Or condition defined for it in consequence 
 * 
 * 
 * @author Alexander Bagerman
 *
 */
public class OrTest extends TestCase {

    private Evaluator       integerEqualEvaluator;
    private Evaluator       integerNotEqualEvaluator;

    private ClassObjectType stageType;

    private ClassObjectType edgeType;

    protected Package       pkg;

    private Stage           markStage;

    protected void setUp() throws Exception {
        super.setUp();
        this.stageType = new ClassObjectType( Stage.class );
        this.edgeType = new ClassObjectType( Edge.class );
        this.integerEqualEvaluator = EvaluatorFactory.getEvaluator( Evaluator.INTEGER_TYPE,
                                                                    Evaluator.EQUAL );
        this.integerNotEqualEvaluator = EvaluatorFactory.getEvaluator( Evaluator.INTEGER_TYPE,
                                                                       Evaluator.NOT_EQUAL );
        this.pkg = new Package( "or" );
    }

    /*
     */
    public void testLeapsNeverGetsToConsequenceOrder() throws Exception {

        this.pkg.addRule( this.getNeverGetsToConsequenceRule() );

        final org.drools.leaps.LeapsRuleBase ruleBase = new org.drools.leaps.LeapsRuleBase();
        ruleBase.addPackage( this.pkg );
        final WorkingMemory workingMemory = ruleBase.newWorkingMemory();
        workingMemory.assertObject( new Stage( Stage.LABELING ) );
        workingMemory.assertObject( new Edge( 1000,
                                              1,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.assertObject( new Edge( 1000,
                                              2,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.assertObject( new Edge( 5555,
                                              3,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.fireAllRules();
        workingMemory.assertObject( new Stage( Stage.DETECT_JUNCTIONS ) );

        workingMemory.fireAllRules();
    }

    /*
     */
    public void testReteooNeverGetsToConsequenceOrder() throws Exception {

        this.pkg.addRule( this.getNeverGetsToConsequenceRule() );

        final org.drools.reteoo.ReteooRuleBase ruleBase = new org.drools.reteoo.ReteooRuleBase();
        ruleBase.addPackage( this.pkg );
        final WorkingMemory workingMemory = ruleBase.newWorkingMemory();
        workingMemory.assertObject( new Stage( Stage.LABELING ) );
        workingMemory.assertObject( new Edge( 1000,
                                              1,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.assertObject( new Edge( 1000,
                                              2,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.assertObject( new Edge( 5555,
                                              3,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.fireAllRules();
        workingMemory.assertObject( new Stage( Stage.DETECT_JUNCTIONS ) );

        workingMemory.fireAllRules();
    }

    /*
     */
    public void testLeapsWorkingButCanNotResolveOrObjectInConsequenceOrder() throws Exception {

        this.pkg.addRule( this.getWorkingButCanNotResolveOrObjectInConsequenceOrder() );

        final org.drools.leaps.LeapsRuleBase ruleBase = new org.drools.leaps.LeapsRuleBase();
        ruleBase.addPackage( this.pkg );
        final WorkingMemory workingMemory = ruleBase.newWorkingMemory();
        workingMemory.assertObject( new Stage( Stage.LABELING ) );
        workingMemory.assertObject( new Edge( 1000,
                                              1,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.assertObject( new Edge( 1000,
                                              2,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.assertObject( new Edge( 5555,
                                              3,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.fireAllRules();
        workingMemory.assertObject( new Stage( Stage.DETECT_JUNCTIONS ) );

        workingMemory.fireAllRules();
    }

    /*
     */
    public void testReteooWorkingButCanNotResolveOrObjectInConsequenceOrder() throws Exception {

        this.pkg.addRule( this.getWorkingButCanNotResolveOrObjectInConsequenceOrder() );

        final org.drools.reteoo.ReteooRuleBase ruleBase = new org.drools.reteoo.ReteooRuleBase();
        ruleBase.addPackage( this.pkg );
        final WorkingMemory workingMemory = ruleBase.newWorkingMemory();
        workingMemory.assertObject( new Stage( Stage.LABELING ) );
        workingMemory.assertObject( new Edge( 1000,
                                              1,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.assertObject( new Edge( 1000,
                                              2,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.assertObject( new Edge( 5555,
                                              3,
                                              false,
                                              Edge.NIL,
                                              Edge.NIL ) );
        workingMemory.fireAllRules();
        workingMemory.assertObject( new Stage( Stage.DETECT_JUNCTIONS ) );

        workingMemory.fireAllRules();
    }

    /*
     * Test method for
     * 'org.drools.leaps.ColumnConstraints.evaluateAlphas(FactHandleImpl, Token,
     * WorkingMemoryImpl)'
     */
    public Rule getNeverGetsToConsequenceRule() throws Exception {
        final Rule rule = new Rule( "NeverGetsToConsequence" );

        final Column stageColumn1 = new Column( 0,
                                                this.stageType,
                                                "stage" );
        stageColumn1.addConstraint( getLiteralConstraint( stageColumn1,
                                                          "value",