[ERA-CVS] src/org/jdaemon/test/util/expression TestExpressionPackage.java, NONE, 1.1

[<je...@23...>]

Update of /cvsroot/era/src/org/jdaemon/test/util/expression
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv12559/test/util/expression

Added Files:
	TestExpressionPackage.java 
Log Message:
Various changes for ERA v2 - 'This time it's Generic...'


--- NEW FILE: TestExpressionPackage.java ---
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.jdaemon.test.util.expression;

import org.jdaemon.util.expression.*;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import java.io.StringWriter;
import java.util.HashMap;
import java.util.HashSet;


/**
 *
 * @author jonathan
 */
public class TestExpressionPackage extends TestCase {
    

    public static String getOperatorPrecedenceTestResult(Expression.Type inner, Expression.Type outer, boolean brackets) {
        StringWriter res = new StringWriter();
        if (brackets) res.append("(");
        res.append("27");
        res.append(SimpleExpressionWriter.DEFAULT_STRING_MAP.get(inner));
        res.append("19");
        if (brackets) res.append(")");
        res.append(SimpleExpressionWriter.DEFAULT_STRING_MAP.get(outer));
        res.append("3");
        return res.toString();
    }
    
    public static void doTestOperatorPrecedence(Expression.Type inner, Expression.Type outer, boolean brackets) throws OutputError {
        StringWriter res = new StringWriter();
        ExpressionWriter writer = new SimpleExpressionWriter(res);
        writer.beginExpression(outer);
        writer.beginExpression(inner);
        writer.writeValue((Integer)27);
        writer.writeValue((Integer)19);
        writer.endExpression(inner);        
        writer.writeValue((Integer)3);
        writer.endExpression(outer);
        assertEquals(res.toString(), getOperatorPrecedenceTestResult(inner, outer, brackets));
    }
     
    public void testOperatorPrecedence() throws OutputError {
        doTestOperatorPrecedence(Expression.Type.ADD, Expression.Type.MUL, true);
        doTestOperatorPrecedence(Expression.Type.MUL, Expression.Type.ADD, false);
        doTestOperatorPrecedence(Expression.Type.ADD, Expression.Type.DIV, true);
        doTestOperatorPrecedence(Expression.Type.DIV, Expression.Type.ADD, false);
        doTestOperatorPrecedence(Expression.Type.DIV, Expression.Type.MUL, false);
        doTestOperatorPrecedence(Expression.Type.MUL, Expression.Type.DIV, true);
        doTestOperatorPrecedence(Expression.Type.ADD, Expression.Type.SUB, false);
        doTestOperatorPrecedence(Expression.Type.SUB, Expression.Type.ADD, true);
    }

    public static String getComparisonTestResult(Expression.Type comp) {
        StringWriter res = new StringWriter();
        res.write("12");
        res.write(SimpleExpressionWriter.DEFAULT_STRING_MAP.get(comp));
        res.write("13");
        return res.toString();
    }
    
    public static void doTestComparison(Expression.Type comp) throws OutputError {
        StringWriter res = new StringWriter();
        ExpressionWriter writer = new SimpleExpressionWriter(res);
        writer.beginExpression(comp);
        writer.writeValue("12");
        writer.writeValue("13");
        writer.endExpression(comp);
        assertEquals(res.toString(), getComparisonTestResult(comp));        
    }
    
    public void testComparison() throws OutputError {
        doTestComparison(Expression.Type.EQ);
        doTestComparison(Expression.Type.LT);
        doTestComparison(Expression.Type.GT);
        doTestComparison(Expression.Type.GTE);
        doTestComparison(Expression.Type.LTE);
    }
    
    public void writeComplexExpression(ExpressionWriter writer) throws OutputError {
        writer.beginExpression(Expression.Type.OR);
        writer.beginExpression(Expression.Type.AND);
        writer.beginExpression(Expression.Type.LT);
        writer.writeValue("13");
        writer.writeValue("11");
        writer.endExpression(Expression.Type.LT);
        writer.beginExpression(Expression.Type.GT);
        writer.writeValue("99");
        writer.writeValue("34");
        writer.endExpression(Expression.Type.GT);
        writer.endExpression(Expression.Type.AND);
        writer.beginExpression(Expression.Type.AND);
        writer.beginExpression(Expression.Type.EQ);
        writer.writeValue("8");
        writer.writeValue("7");
        writer.endExpression(Expression.Type.EQ);
        writer.beginExpression(Expression.Type.NOT);
        writer.beginExpression(Expression.Type.GT);
        writer.writeValue("99");
        writer.writeValue("34");
        writer.endExpression(Expression.Type.GT);
        writer.endExpression(Expression.Type.NOT);
        writer.endExpression(Expression.Type.AND);
        writer.endExpression(Expression.Type.OR);        
    }
    
    public void testComplexExpression() throws OutputError {
        StringWriter res = new StringWriter();
        ExpressionWriter writer = new SimpleExpressionWriter(res);
        writeComplexExpression(writer);
        assertEquals(res.toString(),"13<11 && 99>34 || 8=7 && !(99>34)");
    }
    
    public void testMultipleAdd() throws OutputError {
        StringWriter res = new StringWriter();
        ExpressionWriter writer = new SimpleExpressionWriter(res);
        writer.beginExpression(Expression.Type.ADD);       
        writer.writeValue((Integer)19);
        writer.beginExpression(Expression.Type.ADD);       
        writer.writeValue((Integer)20);
        writer.writeValue((Integer)21);
        writer.endExpression(Expression.Type.ADD);
        writer.endExpression(Expression.Type.ADD);
        assertEquals(res.toString(), "19+20+21");
    }
     
    public void testUserFunc() throws OutputError {
        StringWriter res = new StringWriter();
        ExpressionWriter writer = new SimpleExpressionWriter(res);
        writer.beginExpression(Expression.Type.FUNC);
        writer.writeValue("maximum");
        writer.writeValue((Integer)21);
        writer.writeValue((Integer)12);
        writer.endExpression(Expression.Type.FUNC);
        assertEquals(res.toString(), "maximum(21,12)");
    }
    
    public void doWriteParameterisedExpression(ExpressionWriter writer) throws OutputError {
        writer.beginExpression(Expression.Type.ADD);
        writer.writeParameter("one");
        writer.beginExpression(Expression.Type.MUL);
        writer.writeValue("value");
        writer.writeParameter("two");
        writer.endExpression(Expression.Type.MUL);
        writer.endExpression(Expression.Type.ADD);
        
    }
    
    public void testUnboundParameters() throws OutputError {
        StringWriter res = new StringWriter();
        ExpressionWriter writer = new SimpleExpressionWriter(res);
        doWriteParameterisedExpression(writer);
        assertEquals(res.toString(), "one+value*two");        
    }
    
    public void testParametrisation() throws OutputError {
        StringWriter res = new StringWriter();
        ExpressionWriter writer = new SimpleExpressionWriter(res);
        writer = Expressions.bindParameter(writer, "First", 1);
        writer = Expressions.bindParameter(writer, "Second",2);
        doWriteParameterisedExpression(writer);
        assertEquals(res.toString(), "First+value*Second");
    }
    
    public void testCustomisation() throws OutputError {
        HashMap<Expression.Type, String> string_mappings = new HashMap<Expression.Type,String>(SimpleExpressionWriter.DEFAULT_STRING_MAP);
        HashSet<Expression.Type> infix_set = new HashSet<Expression.Type>(SimpleExpressionWriter.DEFAULT_INFIX_SET);
        HashSet<Expression.Type> prefix_set = new HashSet<Expression.Type>(SimpleExpressionWriter.DEFAULT_PREFIX_SET);
        // Modify mappings by swapping &&, ||, ! for AND OR and NOT
        string_mappings.put(Expression.Type.AND, "AND");
        string_mappings.put(Expression.Type.OR, "OR");
        string_mappings.put(Expression.Type.NOT, "NOT");
        // Remove AND and OR operators from infix set
        infix_set.remove(Expression.Type.AND);
        infix_set.remove(Expression.Type.OR);
        // Remove NOT operator from prefix set
        prefix_set.remove(Expression.Type.NOT);
        StringWriter out = new StringWriter();
        ExpressionWriter writer = new SimpleExpressionWriter(out, string_mappings, infix_set, prefix_set);
        writeComplexExpression(writer);
        assertEquals(out.toString(), "OR(AND(13<11,99>34),AND(8=7,NOT(99>34)))");
    }

    public static TestSuite suite() {
        return new TestSuite(TestExpressionPackage.class);
    }
    
    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }
}