logictransformertest.java

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

package org.drools.rule;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import java.util.List;

import org.drools.DroolsTestCase;

public class LogicTransformerTest extends DroolsTestCase
{
    /**
     * (a||b)&&c
     * 
     * <pre>
     *           and
     *           / \
     *          or  c 
     *         /  \
     *        a    b
     * </pre>
     * 
     * Should become (a&&c)||(b&&c)
     * 
     * <pre>
     *             
     *           or
     *          /  \  
     *         /    \ 
     *        /      \ 
     *         and      and     
     *      / \      / \
     *     a   c    b   c
     * </pre>
     */
    public void testSingleOrAndOrTransformation()
    {
        String a = "a";
        String b = "b";
        String c = "c";

        And and = new And( );
        and.addChild( c );
        Or or = new Or( );
        or.addChild( a );
        or.addChild( b );
        and.addChild( or );

        Or newOr = (Or) LogicTransformer.getInstance( ).applyOrTransformation( and,
                                                                               or );

        assertLength( 2,
                      newOr.getChildren( ) );
        assertEquals( And.class,
                      newOr.getChildren( ).get( 0 ).getClass( ) );
        assertEquals( And.class,
                      newOr.getChildren( ).get( 1 ).getClass( ) );

        And and1 = (And) newOr.getChildren( ).get( 0 );
        assertContains( c,
                        and1.getChildren( ) );
        assertContains( a,
                        and1.getChildren( ) );

        And and2 = (And) newOr.getChildren( ).get( 1 );
        assertContains( c,
                        and2.getChildren( ) );
        assertContains( b,
                        and2.getChildren( ) );

    }

    /**
     * (a||b)&&c
     * 
     * <pre>
     *               And
     *              /|\ \__
     *            _/ | \_  \_
     *           /   |   \   \  
     *          or   |   or   not
     *         /   \ |  / \    |
     *        a    b c d   e   f
     * </pre>
     * 
     * Should become (a&&c)||(b&&c)
     * 
     * <pre>
     *                       /\
     *                     _/  \_
     *                    /      \
     *                  _/|       |\_
     *               __/  |       |  \__
     *            __/     |       |     \__
     *           /        |       |        \
     *          and      and     and      and
     *         /||\     /||\     /||\     /||\
     *        a cd Not a ce Not b cd Not b ce Not
     *              |        |        |        |
     *              f        f        f        f
     * </pre>
     */
    public void testMultipleOrAndOrTransformation()
    {
        String a = "a";
        String b = "b";
        String c = "c";
        String d = "d";
        String e = "e";
        String f = "f";

        And and = new And( );
        Or or = new Or( );
        or.addChild( a );
        or.addChild( b );
        and.addChild( or );
        and.addChild( c );

        Or or2 = new Or( );

        or2.addChild( d );
        or2.addChild( e );
        and.addChild( or2 );

        Not not = new Not( );
        not.addChild( f );
        and.addChild( not );

        Or newOr = (Or) LogicTransformer.getInstance( ).applyOrTransformation( and,
                                                                               or );

        assertLength( 4,
                      newOr.getChildren( ) );
        assertEquals( And.class,
                      newOr.getChildren( ).get( 0 ).getClass( ) );
        assertEquals( And.class,
                      newOr.getChildren( ).get( 1 ).getClass( ) );
        assertEquals( And.class,
                      newOr.getChildren( ).get( 2 ).getClass( ) );
        assertEquals( And.class,
                      newOr.getChildren( ).get( 3 ).getClass( ) );

        And and1 = (And) newOr.getChildren( ).get( 0 );
        assertLength( 4,
                      and1.getChildren( ) );
        assertContains( a,
                        and1.getChildren( ) );
        assertContains( c,
                        and1.getChildren( ) );
        assertContains( d,
                        and1.getChildren( ) );
        assertContains( not,
                        and1.getChildren( ) );

        and1 = (And) newOr.getChildren( ).get( 1 );
        assertLength( 4,
                      and1.getChildren( ) );
        assertContains( a,
                        and1.getChildren( ) );
        assertContains( c,
                        and1.getChildren( ) );
        assertContains( e,
                        and1.getChildren( ) );
        assertContains( not,
                        and1.getChildren( ) );

        and1 = (And) newOr.getChildren( ).get( 2 );
        assertLength( 4,
                      and1.getChildren( ) );
        assertContains( b,
                        and1.getChildren( ) );
        assertContains( c,
                        and1.getChildren( ) );
        assertContains( d,
                        and1.getChildren( ) );
        assertContains( not,
                        and1.getChildren( ) );

        and1 = (And) newOr.getChildren( ).get( 3 );
        assertLength( 4,
                      and1.getChildren( ) );
        assertContains( b,
                        and1.getChildren( ) );
        assertContains( c,
                        and1.getChildren( ) );
        assertContains( e,
                        and1.getChildren( ) );
        assertContains( not,
                        and1.getChildren( ) );
    }

    /**
     * (Not (OR (A B)
     * 
     * <pre>
     *           Not
     *            | 
     *           or   
     *          /  \
     *         a    b
     * </pre>
     * 
     * (And ( Not (a) Exist (b)) )
     * 
     * <pre>
     *           And   
     *          /   \
     *         Not  Not
     *         |     |
     *         a     b
     * </pre>
     * </pre>
     */
    public void testNotOrTransformation()
    {
        String a = "a";
        String b = "b";

        Not not = new Not( );
        Or or = new Or( );
        not.addChild( or );

        or.addChild( a );
        or.addChild( b );

        And newAnd = (And) LogicTransformer.getInstance( ).applyOrTransformation( not,
                                                                                  or );

        assertLength( 2,
                      newAnd.getChildren( ) );
        assertEquals( Not.class,
                      newAnd.getChildren( ).get( 0 ).getClass( ) );
        assertEquals( Not.class,
                      newAnd.getChildren( ).get( 1 ).getClass( ) );

        Not not1 = (Not) newAnd.getChildren( ).get( 0 );
        assertContains( a,
                        not1.getChildren( ) );

        Not not2 = (Not) newAnd.getChildren( ).get( 1 );
        assertContains( b,
                        not2.getChildren( ) );
    }

    /**
     * (Exist (OR (A B)
     * 
     * <pre>
     *           Not
     *            | 
     *           or   
     *          /  \
     *         a    b
     * </pre>
     * 
     * (And ( Exist (a) Exist (b)) )
     * 
     * <pre>
     *           And   
     *          /   \
     *         Not  Not
     *         |     |
     *         a     b
     * </pre>
     * </pre>
     */
    public void testExistOrTransformation()
    {
        String a = "a";
        String b = "b";

        Exist exist = new Exist( );
        Or or = new Or( );
        exist.addChild( or );

        or.addChild( a );
        or.addChild( b );

        And newAnd = (And) LogicTransformer.getInstance( ).applyOrTransformation( exist,
                                                                                  or );

        assertLength( 2,
                      newAnd.getChildren( ) );
        assertEquals( Exist.class,
                      newAnd.getChildren( ).get( 0 ).getClass( ) );
        assertEquals( Exist.class,
                      newAnd.getChildren( ).get( 1 ).getClass( ) );

        Exist exist1 = (Exist) newAnd.getChildren( ).get( 0 );
        assertContains( a,
                        exist1.getChildren( ) );

        Exist exist2 = (Exist) newAnd.getChildren( ).get( 1 );
        assertContains( b,
                        exist2.getChildren( ) );
    }

    public void testDuplicatTransformation()
    {
        String a = "a";
        String b = "b";
        String c = "c";
        String d = "d";

        And and1 = new And( );
        and1.addChild( a );
        and1.addChild( b );

        And and2 = new And( );
        and2.addChild( c );
        and2.addChild( d );

        and1.addChild( and2 );