/*
 * FormulaVariableMathTest.java
 * JUnit based test
 *
 * Created on July 31, 2006, 3:58 PM
 */

package com.accountingenhancements.formula;

import com.accountingenhancements.common.SupportParameters;
import junit.framework.*;
import java.text.ParseException;

/**
 *
 * @author lofgren
 */
public class FormulaVariableMathTest extends TestCase {
    
    public FormulaVariableMathTest(String testName) {
        super(testName);
    }

    protected void setUp() throws Exception {
    }

    protected void tearDown() throws Exception {
    }

    public static Test suite() {
        TestSuite suite = new TestSuite(FormulaVariableMathTest.class);
        
        return suite;
    }

    /**
     * Test of solveUnaryOfVariable method, of class com.accountingenhancements.formula.FormulaVariableMath.
     */
    public void testSolveUnaryOfVariable() throws Exception {
        System.out.println("solveUnaryOfVariable");
        
        int unaryOperator = FormulaVariable.TYPE_OPERATOR_UNARY_NOT;
        FormulaVariable variable;
        FormulaVariableList variableList = null;
        SupportParameters supportParameters = null;
        FormulaFunctionList functionList = null;
        int resolveEverythingAboveLevel = 0;
        StringBuilder tmpString=new StringBuilder();
        boolean error;
        
        variable = new FormulaVariable("",false,0,0);
        FormulaVariable result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <boolean> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_BOOLEAN);
        assertTrue("Exp: <true> Was: <false>",result.getBoolean());
        
        variable=new FormulaVariable("",true,0,0);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <boolean> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_BOOLEAN);
        assertFalse("Exp: <false> Was: <true>",result.getBoolean());
        
        variable = new FormulaVariable("",(long)0,0,0);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <boolean> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_BOOLEAN);
        assertTrue("Exp: <true> Was: <false>",result.getBoolean());
        
        variable=new FormulaVariable("",(long)7,0,0);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <boolean> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_BOOLEAN);
        assertFalse("Exp: <false> Was: <true>",result.getBoolean());
        
        variable = new FormulaVariable("",(double).005,1,0);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <boolean> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_BOOLEAN);
        assertTrue("Exp: <true> Was: <false>",result.getBoolean());
        
        variable=new FormulaVariable("",(double)2.3,0,0);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <boolean> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_BOOLEAN);
        assertFalse("Exp: <false> Was: <true>",result.getBoolean());
        
        variable = new FormulaVariable("","",0);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <boolean> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_BOOLEAN);
        assertTrue("Exp: <true> Was: <false>",result.getBoolean());
        
        variable=new FormulaVariable("","a",0,false);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <boolean> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_BOOLEAN);
        assertFalse("Exp: <false> Was: <true>",result.getBoolean());
        
        
        unaryOperator=FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT;
        
        variable = new FormulaVariable("",false,0,0);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <boolean> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_BOOLEAN);
        assertTrue("Exp: <true> Was: <false>",result.getBoolean());
        
        variable=new FormulaVariable("",true,0,0);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <boolean> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_BOOLEAN);
        assertFalse("Exp: <false> Was: <true>",result.getBoolean());
        
        variable = new FormulaVariable("",(long)440022,0);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <long> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_LONG);
        assertEquals((long)-440023,(long)result.getLong());
        
        variable = new FormulaVariable("","ABCD",0,false);
        result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertTrue("Exp: <String> Was: <"+FormulaVariable.TYPE_TO_STRING_ARRAY[result.getVariableType()]+">",result.getVariableType()==FormulaVariable.TYPE_STRING);
        for(int i=0;i<result.getString().length();i++)tmpString.append(Integer.toHexString(result.getString().charAt(i)).substring(2));
        assertTrue("Exp Hex: <BEBDBCBB> Was: <"+tmpString.toString()+">",tmpString.toString().equalsIgnoreCase("BEBDBCBB"));
        
        variable=new FormulaVariable("",new java.util.Date(0),0);
        error=false;
        try{
            result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        variable=new FormulaVariable("",(double)2.34,0);
        error=false;
        try{
            result = FormulaVariableMath.solveUnaryOfVariable(unaryOperator, variable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        
        
    }
    
    /**
     *Test of applyOperatorToTwoVariables(boolean, int, boolean) method, of class com.accountingenhancements.formula.FormulaVariableMath.
     */
    public void testApplyOperatorToTwoVariables_boolean_int_boolean() throws Exception{
        System.out.println("applyOperatorToTwoVariables(boolean, int, boolean");
        
        boolean left,right;
        int operator;
        boolean result;
        boolean error;
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT;
        left=false;
        right=false;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_NOT;
        left=false;
        right=false;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_EQUALS;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_NOT_EQUAL;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_OR;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_AND;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_MULTIPLY;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_DIVIDE;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_MODULUS;
        left=false;
        right=false;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_AND;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_OR;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_XOR;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_PLUS;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_MINUS;
        left=true;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=true;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(true,result);
        left=false;
        right=true;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        left=false;
        right=false;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(false,result);
        
        
    }
    
    /**
     *Test of applyOperatorToTwoVariables(long, int, long) method, of class com.accountingenhancements.formula.FormulaVariableMath.
     */
    public void testApplyOperatorToTwoVariables_long_int_long() throws Exception{
        System.out.println("applyOperatorToTwoVariables(long, int, long");
        
        long left,right;
        int operator;
        long result;
        boolean error;
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT;
        left=0;
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_NOT;
        left=0;
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_EQUALS;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_NOT_EQUAL;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_OR;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_AND;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_MULTIPLY;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(9L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_DIVIDE;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=9;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3L,result);
        left=3;
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_MODULUS;
        left=4;
        right=4;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=6;
        right=2;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=11;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(2L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_AND;
        left=3;
        right=6;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(2L,result);
        left=9;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=8;
        right=2;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_OR;
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3L,result);
        left=6;
        right=8;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(14L,result);
        left=6;
        right=4;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(6L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_XOR;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3L,result);
        left=2;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_PLUS;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(6L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_MINUS;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3L,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(-3L,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0L,result);
        
        
    }
    
    /**
     *Test of applyOperatorToTwoVariables(Date, int, Date) method, of class com.accountingenhancements.formula.FormulaVariableMath.
     */
    public void testApplyOperatorToTwoVariables_Date_int_Date() throws Exception{
        System.out.println("applyOperatorToTwoVariables(Date, int, Date");
        
        java.util.Date left,right;
        int operator;
        long result;
        boolean error;
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_NOT;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_EQUALS;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_NOT_EQUAL;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_OR;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_AND;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_MULTIPLY;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_DIVIDE;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_MODULUS;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_AND;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_OR;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_XOR;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_PLUS;
        left=new java.util.Date(0L);
        right=new java.util.Date(0L);
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_MINUS;
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("MM/dd/yyyy");
        left = sdf.parse("02/20/2004");
        right = sdf.parse("03/02/2004");
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(-11L,result);
        left = sdf.parse("06/20/2006");
        right = sdf.parse("05/02/2006");
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(49L,result);
        
    }
    
    /**
     *Test of applyOperatorToTwoVariables(Date, int, Long) method, of class com.accountingenhancements.formula.FormulaVariableMath.
     */
    public void testApplyOperatorToTwoVariables_Date_int_Long() throws Exception{
        System.out.println("applyOperatorToTwoVariables(Date, int, Long");
        
        java.util.Date left;
        long right;
        int operator;
        java.util.Date result;
        boolean error;
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("MM/dd/yyyy");
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_NOT;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_EQUALS;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_NOT_EQUAL;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_OR;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_AND;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_MULTIPLY;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_DIVIDE;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_MODULUS;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_AND;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_OR;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_XOR;
        left=new java.util.Date(0L);
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_PLUS;
        left = sdf.parse("03/02/2004");
        right=-11L;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertTrue("Was: <"+sdf.format(result)+"> Expected: <02/20/2004>",sdf.format(result).equals("02/20/2004"));
        left = sdf.parse("02/20/2004");
        right=+11L;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertTrue("Was: <"+sdf.format(result)+"> Expected: <03/02/2004>",sdf.format(result).equals("03/02/2004"));
        
        operator=FormulaVariable.TYPE_OPERATOR_MINUS;
        left = sdf.parse("03/02/2004");
        right=11L;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertTrue("Was: <"+sdf.format(result)+"> Expected: <02/20/2004>",sdf.format(result).equals("02/20/2004"));
        left = sdf.parse("02/20/2004");
        right=-11L;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertTrue("Was: <"+sdf.format(result)+"> Expected: <03/02/2004>",sdf.format(result).equals("03/02/2004"));
        
    }
    
    /**
     *Test of applyOperatorToTwoVariables(double, int, double) method, of class com.accountingenhancements.formula.FormulaVariableMath.
     */
    public void testApplyOperatorToTwoVariables_double_int_double() throws Exception{
        System.out.println("applyOperatorToTwoVariables(double, int, double");
        
        double left,right;
        int operator;
        double result;
        boolean error;
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT;
        left=0;
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_NOT;
        left=0;
        right=0;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_EQUALS;
        left=3.012;
        right=3.012;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_NOT_EQUAL;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_OR;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_AND;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_MULTIPLY;
        left=3.3;
        right=3.3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1089L,java.lang.Math.round(result*100));
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_DIVIDE;
        left=3.3;
        right=3.3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=9;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(300L,java.lang.Math.round(result*100));
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertTrue("Was: <"+result+"> expected: <Infinity>",Double.isInfinite(result));
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=0;
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_MODULUS;
        left=4;
        right=4;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=6.0;
        right=2.0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=11;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(2.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_AND;
        left=3;
        right=6;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(2.0,result);
        left=9;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=8;
        right=2;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_OR;
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3.0,result);
        left=6;
        right=8;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(14.0,result);
        left=6;
        right=4;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(6.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_XOR;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3.0,result);
        left=2;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(1.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_PLUS;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(6.0,result);
        left=2.25;
        right=3.08;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(533L,java.lang.Math.round(result*100));
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_MINUS;
        left=3;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        left=3;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(3.0,result);
        left=0;
        right=3;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(-3.0,result);
        left=0;
        right=0;
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertEquals(0.0,result);
        
        
    }
    
    /**
     *Test of applyOperatorToTwoVariables(String, int, String) method, of class com.accountingenhancements.formula.FormulaVariableMath.
     */
    public void testApplyOperatorToTwoVariables_String_int_String() throws Exception{
        System.out.println("applyOperatorToTwoVariables(String, int, String");
        
        String left,right;
        int operator;
        String result;
        boolean error;
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_NOT;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_EQUALS;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_NOT_EQUAL;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_OR;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_AND;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_MULTIPLY;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_DIVIDE;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_MODULUS;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_AND;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_OR;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_XOR;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_PLUS;
        left="a";
        right="heLLo";
        result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        assertTrue("Was: <"+result+"> Expected: <aheLLo",result.equals("aheLLo"));
        
        operator=FormulaVariable.TYPE_OPERATOR_MINUS;
        left="a";
        right="a";
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToTwoVariables(left,operator,right);
        }catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
    }
    
    /**
     * Test of applyOperatorToTwoVariables method, of class com.accountingenhancements.formula.FormulaVariableMath.
     */
    public void testApplyOperatorToTwoVariables() throws Exception {
        System.out.println("applyOperatorToTwoVariables");
        
        FormulaVariable leftVariable = null;
        int operator = 0;
        FormulaVariable rightVariable = null;
        FormulaVariableList variableList = null;
        SupportParameters supportParameters = null;
        FormulaFunctionList functionList = null;
        int resolveEverythingAboveLevel = 0;
        FormulaVariable result;
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("MM/dd/yyyy");
        
        //long to long, long to boolean, or boolean to long
        operator=FormulaVariable.TYPE_OPERATOR_PLUS;
        leftVariable = new FormulaVariable("",3L,0);
        rightVariable = new FormulaVariable("",4L,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(7L,(long)result.getLong());
        leftVariable = new FormulaVariable("",3L,0);
        rightVariable = new FormulaVariable("",false,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(3L,(long)result.getLong());
        leftVariable = new FormulaVariable("",3L,0);
        rightVariable = new FormulaVariable("",true,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(4L,(long)result.getLong());
        leftVariable = new FormulaVariable("",false,0);
        rightVariable = new FormulaVariable("",4L,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(4L,(long)result.getLong());
        leftVariable = new FormulaVariable("",true,0);
        rightVariable = new FormulaVariable("",4L,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(5L,(long)result.getLong());
        
        //String to anything, anything to String
        operator=FormulaVariable.TYPE_OPERATOR_PLUS;
        leftVariable = new FormulaVariable("","Hi there ",0,false);
        rightVariable = new FormulaVariable("","test",0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <Hi there test>",result.getString().equals("Hi there test"));
        leftVariable = new FormulaVariable("","Hi there ",0,false);
        rightVariable = new FormulaVariable("",2L,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <Hi there 2>",result.getString().equals("Hi there 2"));
        leftVariable = new FormulaVariable("","Hi there ",0,false);
        rightVariable = new FormulaVariable("",false,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <Hi there false>",result.getString().equals("Hi there false"));
        leftVariable = new FormulaVariable("","Hi there ",0,false);
        rightVariable = new FormulaVariable("",2.0344,2,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <Hi there 2.03>",result.getString().equals("Hi there 2.03"));
        leftVariable = new FormulaVariable("","Hi there ",0,false);
        rightVariable = new FormulaVariable("",sdf.parse("04/12/2006"),0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <Hi there 04/12/2006>",result.getString().equals("Hi there 04/12/2006"));
        leftVariable = new FormulaVariable("",2L,0);
        rightVariable = new FormulaVariable(""," Hi there",0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <2 Hi there>",result.getString().equals("2 Hi there"));
        leftVariable = new FormulaVariable("",false,0);
        rightVariable = new FormulaVariable(""," Hi there",0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <false Hi there>",result.getString().equals("false Hi there"));
        leftVariable = new FormulaVariable("",2.0344,2,0);
        rightVariable = new FormulaVariable(""," Hi there",0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <2.03 Hi there>",result.getString().equals("2.03 Hi there"));
        leftVariable = new FormulaVariable("",sdf.parse("04/12/2006"),0);
        rightVariable = new FormulaVariable(""," Hi there",0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <04/12/2006 Hi there>",result.getString().equals("04/12/2006 Hi there"));
        
        operator=FormulaVariable.TYPE_OPERATOR_EQUALS;
        leftVariable = new FormulaVariable("","hi",0,false);
        rightVariable = new FormulaVariable(""," Hi there",0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertFalse(result.getBoolean());
        operator=FormulaVariable.TYPE_OPERATOR_EQUALS;
        leftVariable = new FormulaVariable("","Hi there",0,false);
        rightVariable = new FormulaVariable("","Hi there",0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertTrue(result.getBoolean());
        
        //boolean to boolean
        operator = FormulaVariable.TYPE_OPERATOR_AND;
        leftVariable = new FormulaVariable("",false,0);
        rightVariable = new FormulaVariable("",true,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(false,result.getBoolean());
        
        //Test Unary Operators while we are doing boolean to boolean
        operator = FormulaVariable.TYPE_OPERATOR_AND;
        leftVariable = new FormulaVariable("",false,0);
        rightVariable = new FormulaVariable("",true,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(FormulaVariable.TYPE_OPERATOR_UNARY_NOT,leftVariable, operator, null, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        leftVariable = new FormulaVariable("",true,0);
        rightVariable = new FormulaVariable("",true,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(null,leftVariable, operator, FormulaVariable.TYPE_OPERATOR_UNARY_NOT, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(false,result.getBoolean());
        leftVariable = new FormulaVariable("",true,0);
        rightVariable = new FormulaVariable("",false,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(null,leftVariable, operator, FormulaVariable.TYPE_OPERATOR_UNARY_NOT, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        leftVariable = new FormulaVariable("",false,0);
        rightVariable = new FormulaVariable("",false,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(FormulaVariable.TYPE_OPERATOR_UNARY_NOT,leftVariable, operator, FormulaVariable.TYPE_OPERATOR_UNARY_NOT, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        leftVariable = new FormulaVariable("",false,0);
        rightVariable = new FormulaVariable("",false,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT,leftVariable, operator, FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        leftVariable = new FormulaVariable("",true,0);
        rightVariable = new FormulaVariable("",true,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(FormulaVariable.TYPE_OPERATOR_PLUS,leftVariable, operator, FormulaVariable.TYPE_OPERATOR_MULTIPLY, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean()); //The invalid UNARY operators should have been ignored with no error.
        
        //Date to Date or date-like string to date-like string or any combination
        operator = FormulaVariable.TYPE_OPERATOR_EQUALS;
        leftVariable = new FormulaVariable("",sdf.parse("04/12/2006"),0);
        rightVariable = new FormulaVariable("",sdf.parse("05/12/2006"),0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(false,result.getBoolean());
        operator = FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        leftVariable = new FormulaVariable("",sdf.parse("04/12/2006"),0);
        rightVariable = new FormulaVariable("",sdf.parse("05/12/2006"),0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        operator = FormulaVariable.TYPE_OPERATOR_MINUS;
        leftVariable = new FormulaVariable("",sdf.parse("04/12/2006"),0);
        rightVariable = new FormulaVariable("",sdf.parse("05/12/2006"),0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(-30L,(long)result.getLong());
        operator = FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        leftVariable = new FormulaVariable("",sdf.parse("04/12/2006"),0);
        rightVariable = new FormulaVariable("","05/12/2006",FormulaVariable.TYPE_STRING,0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        operator = FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        leftVariable = new FormulaVariable("",sdf.parse("05/12/2006"),0);
        rightVariable = new FormulaVariable("","04/12/2006",FormulaVariable.TYPE_STRING,0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(false,result.getBoolean());
        operator = FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        leftVariable = new FormulaVariable("","05/12/2006",FormulaVariable.TYPE_STRING,0,false);
        rightVariable = new FormulaVariable("",sdf.parse("04/12/2006"),0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(false,result.getBoolean());
        operator = FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        leftVariable = new FormulaVariable("","04/12/2006",FormulaVariable.TYPE_STRING,0,false);
        rightVariable = new FormulaVariable("",sdf.parse("05/12/2006"),0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        operator = FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        leftVariable = new FormulaVariable("","05/12/2006",FormulaVariable.TYPE_STRING,0,false);
        rightVariable = new FormulaVariable("","04/12/2006",FormulaVariable.TYPE_STRING,0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(false,result.getBoolean());
        operator = FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        leftVariable = new FormulaVariable("","04/12/2006",FormulaVariable.TYPE_STRING,0,false);
        rightVariable = new FormulaVariable("","05/12/2006",FormulaVariable.TYPE_STRING,0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        operator = FormulaVariable.TYPE_OPERATOR_MINUS;
        leftVariable = new FormulaVariable("","05/12/2006",FormulaVariable.TYPE_STRING,0,false);
        rightVariable = new FormulaVariable("","04/12/2006",FormulaVariable.TYPE_STRING,0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(30,result.getLong().intValue());
        operator = FormulaVariable.TYPE_OPERATOR_MINUS;
        leftVariable = new FormulaVariable("","01/12/2007",FormulaVariable.TYPE_STRING,0,false);
        rightVariable = new FormulaVariable("","01/12/2006",FormulaVariable.TYPE_STRING,0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(365,result.getLong().intValue());
        operator = FormulaVariable.TYPE_OPERATOR_MINUS;
        leftVariable = new FormulaVariable("","05/12/2006",FormulaVariable.TYPE_STRING,0,false);
        rightVariable = new FormulaVariable("","05/12/2006",FormulaVariable.TYPE_STRING,0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(0,result.getLong().intValue());
        operator = FormulaVariable.TYPE_OPERATOR_MINUS;
        leftVariable = new FormulaVariable("","08/14/2006",FormulaVariable.TYPE_STRING,0,false);
        rightVariable = new FormulaVariable("","1/3/1",FormulaVariable.TYPE_STRING,0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(2048,result.getLong().intValue());
        operator = FormulaVariable.TYPE_OPERATOR_MINUS;
        leftVariable = new FormulaVariable("","08/14/2006",FormulaVariable.TYPE_STRING,0,false);
        rightVariable = new FormulaVariable("","1/4/1",FormulaVariable.TYPE_STRING,0,false);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(2047,result.getLong().intValue());
        
        
        
        
        //Date to long or double
        operator = FormulaVariable.TYPE_OPERATOR_PLUS;
        leftVariable=new FormulaVariable("",sdf.parse("04/12/2006"),0);
        rightVariable = new FormulaVariable("",30L,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_DATE,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <05/12/2006>",result.getString().equals("05/12/2006"));
        leftVariable=new FormulaVariable("",sdf.parse("04/12/2006"),0);
        rightVariable = new FormulaVariable("",31.3,2,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_DATE,result.getVariableType());
        assertTrue("Was: <"+result.getString()+"> Expected: <05/13/2006>",result.getString().equals("05/13/2006"));
        
        //double to double, double to long,  long to double
        operator = FormulaVariable.TYPE_OPERATOR_PLUS;
        leftVariable = new FormulaVariable("",31.325,3,0);
        rightVariable = new FormulaVariable("",12.01,2,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_DOUBLE,result.getVariableType());
        assertEquals(2,result.getScale());
        assertTrue("Was: <"+result.getString()+"> Expected: <43.34>",result.getString().equals("43.34"));
        operator = FormulaVariable.TYPE_OPERATOR_MULTIPLY;
        leftVariable = new FormulaVariable("",31.325,3,0);
        rightVariable = new FormulaVariable("",12.01,2,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_DOUBLE,result.getVariableType());
        assertEquals(1,result.getScale());
        assertTrue("Was: <"+result.getString()+"> Expected: <43.34>",result.getString().equals("376.2"));
        operator = FormulaVariable.TYPE_OPERATOR_PLUS;
        leftVariable = new FormulaVariable("",31.32,2,0);
        rightVariable = new FormulaVariable("",10L,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_DOUBLE,result.getVariableType());
        assertEquals(2,result.getScale());
        assertTrue("Was: <"+result.getString()+"> Expected: <41.32>",result.getString().equals("41.32"));
        operator = FormulaVariable.TYPE_OPERATOR_PLUS;
        leftVariable = new FormulaVariable("",10L,0);
        rightVariable = new FormulaVariable("",31.32,2,0);
        result = FormulaVariableMath.applyOperatorToTwoVariables(leftVariable, operator, rightVariable, variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_DOUBLE,result.getVariableType());
        assertEquals(2,result.getScale());
        assertTrue("Was: <"+result.getString()+"> Expected: <41.32>",result.getString().equals("41.32"));
        
    }

    /**
     * Test of applyOperatorToCompareDates method, of class com.accountingenhancements.formula.FormulaVariableMath.
     */
    public void testApplyOperatorToCompareDates() {
        System.out.println("applyOperatorToCompareDates");
        
        java.util.Date left = null;
        int operator = 0;
        java.util.Date right = null;
        boolean result;
        boolean error;
        
        left=new  java.util.Date(1151064000000L);
        right=new java.util.Date(1151236800000L);
        
        error=false;
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT;
        try{
            result=FormulaVariableMath.applyOperatorToCompareDates(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        error=false;
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_NOT;
        try{
            result=FormulaVariableMath.applyOperatorToCompareDates(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_EQUALS;
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(false, result);
        result = FormulaVariableMath.applyOperatorToCompareDates(right, operator, left);
        assertEquals(false, result);
        left=new java.util.Date(1151236800200L); //Setting to same day but different time, should report equals.
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(true, result);
        
        left=new  java.util.Date(1151064000000L);
        right=new java.util.Date(1151236800000L);
        operator=FormulaVariable.TYPE_OPERATOR_NOT_EQUAL;
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(true, result);
        result = FormulaVariableMath.applyOperatorToCompareDates(right, operator, left);
        assertEquals(true, result);
        left=new java.util.Date(1151236800200L);
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(false, result);
        
        left=new  java.util.Date(1151064000000L);
        right=new java.util.Date(1151236800000L);
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(true, result);
        result = FormulaVariableMath.applyOperatorToCompareDates(right, operator, left);
        assertEquals(false, result);
        left=new java.util.Date(1151236800000L);
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(false, result);
        
        left=new  java.util.Date(1151064000000L);
        right=new java.util.Date(1151236800000L);
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL;
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(true, result);
        result = FormulaVariableMath.applyOperatorToCompareDates(right, operator, left);
        assertEquals(false, result);
        left=new java.util.Date(1151236800000L);
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(true, result);
        
        left=new  java.util.Date(1151064000000L);
        right=new java.util.Date(1151236800000L);
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN;
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(false, result);
        result = FormulaVariableMath.applyOperatorToCompareDates(right, operator, left);
        assertEquals(true, result);
        left=new java.util.Date(1151236800000L);
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(false, result);
        
        left=new  java.util.Date(1151064000000L);
        right=new java.util.Date(1151236800000L);
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL;
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(false, result);
        result = FormulaVariableMath.applyOperatorToCompareDates(right, operator, left);
        assertEquals(true, result);
        left=new java.util.Date(1151236800000L);
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(true, result);
        
        operator=FormulaVariable.TYPE_OPERATOR_OR;
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(true, result);
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, (java.util.Date)null);
        assertEquals(true, result);
        result = FormulaVariableMath.applyOperatorToCompareDates((java.util.Date)null, operator, right);
        assertEquals(true, result);
        result = FormulaVariableMath.applyOperatorToCompareDates((java.util.Date)null, operator, (java.util.Date)null);
        assertEquals(false, result);
        
        operator=FormulaVariable.TYPE_OPERATOR_AND;
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, right);
        assertEquals(true, result);
        result = FormulaVariableMath.applyOperatorToCompareDates(left, operator, (java.util.Date)null);
        assertEquals(false, result);
        result = FormulaVariableMath.applyOperatorToCompareDates((java.util.Date)null, operator, right);
        assertEquals(false, result);
        
        error=false;
        operator=FormulaVariable.TYPE_OPERATOR_MULTIPLY;
        try{
            result=FormulaVariableMath.applyOperatorToCompareDates(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        error=false;
        operator=FormulaVariable.TYPE_OPERATOR_DIVIDE;
        try{
            result=FormulaVariableMath.applyOperatorToCompareDates(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        error=false;
        operator=FormulaVariable.TYPE_OPERATOR_MODULUS;
        try{
            result=FormulaVariableMath.applyOperatorToCompareDates(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        error=false;
        operator=FormulaVariable.TYPE_OPERATOR_BIT_AND;
        try{
            result=FormulaVariableMath.applyOperatorToCompareDates(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        error=false;
        operator=FormulaVariable.TYPE_OPERATOR_BIT_OR;
        try{
            result=FormulaVariableMath.applyOperatorToCompareDates(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        error=false;
        operator=FormulaVariable.TYPE_OPERATOR_BIT_XOR;
        try{
            result=FormulaVariableMath.applyOperatorToCompareDates(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        error=false;
        operator=FormulaVariable.TYPE_OPERATOR_PLUS;
        try{
            result=FormulaVariableMath.applyOperatorToCompareDates(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        error=false;
        operator=FormulaVariable.TYPE_OPERATOR_MINUS;
        try{
            result=FormulaVariableMath.applyOperatorToCompareDates(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        
    }

    /**
     * Test of applyOperatorToCompareStrings method, of class com.accountingenhancements.formula.FormulaVariableMath.
     */
    public void testApplyOperatorToCompareStrings() {
        System.out.println("applyOperatorToCompareStrings");
        
        String left;
        int operator = 0;
        String right;
        boolean error;
        boolean result;
        
        left="AAAA";
        right="AAAB";
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_UNARY_NOT;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_EQUALS;
        left="AAAA";
        right="AAAB";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(false,result);
        right="aaaa";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(false,result);
        right="AAAA";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(true,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_NOT_EQUAL;
        left="AAAA";
        right="AAAB";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(true,result);
        right="aaaa";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(true,result);
        right="AAAA";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL;
        left="AAAA";
        right="AAAB";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(true,result);
        result=FormulaVariableMath.applyOperatorToCompareStrings(right,operator,left);
        assertEquals(false,result);
        right="AAAA";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(true,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_LESS_THAN;
        left="AAAA";
        right="AAAB";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(true,result);
        result=FormulaVariableMath.applyOperatorToCompareStrings(right,operator,left);
        assertEquals(false,result);
        right="AAAA";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL;
        left="AAAA";
        right="AAAB";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(false,result);
        result=FormulaVariableMath.applyOperatorToCompareStrings(right,operator,left);
        assertEquals(true,result);
        right="AAAA";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(true,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_GREATER_THAN;
        left="AAAA";
        right="AAAB";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(false,result);
        result=FormulaVariableMath.applyOperatorToCompareStrings(right,operator,left);
        assertEquals(true,result);
        right="AAAA";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_OR;
        left="A";
        right=null;
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(true,result);
        result=FormulaVariableMath.applyOperatorToCompareStrings(right,operator,left);
        assertEquals(true,result);
        result=FormulaVariableMath.applyOperatorToCompareStrings(null,operator,null);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_AND;
        left="A";
        right="BCD";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(true,result);
        left="A";
        right=null;
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(false,result);
        left=null;
        right="ABc";
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(false,result);
        left=null;
        right=null;
        result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        assertEquals(false,result);
        
        operator=FormulaVariable.TYPE_OPERATOR_MULTIPLY;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_DIVIDE;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_MODULUS;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_AND;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_OR;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_BIT_XOR;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_PLUS;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
        operator=FormulaVariable.TYPE_OPERATOR_MINUS;
        error=false;
        try{
            result=FormulaVariableMath.applyOperatorToCompareStrings(left,operator,right);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
    }
    
}