/*
 * FormulaVariableStackTest.java
 * JUnit based test
 *
 * Created on July 13, 2006, 12:39 PM
 */

package com.accountingenhancements.formula;

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

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

    protected void setUp() throws Exception {
    }

    protected void tearDown() throws Exception {
    }

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

    /**
     * Test of parseFormula method, of class com.accountingenhancements.formula.FormulaVariableStack.
     */
    public void testParseFormula() throws Exception {
        System.out.println("parseFormula");
        boolean error;
        String formula = "A + B(c||!D)";
        FormulaVariableStack instance = new FormulaVariableStack();
        String parseMessage="";
        String expectedMessage;
        instance.parseFormula(formula);
        assertEquals(3,instance.size());
        assertTrue("Was: <"+instance.get(0).toString()+"> Expected: <A>",instance.get(0).toString().equals("A"));
        assertEquals(instance.get(0).isOperator(),false);
        assertTrue("Was: <"+instance.get(1).toString()+"> Expected: <+>",instance.get(1).toString().equals("+"));
        assertEquals(instance.get(1).isOperator(),true);
        assertTrue("Was: <"+instance.get(2).toString()+"> Expected: <B(c||!D)>",instance.get(2).toString().equals("B(c||!D)"));
        assertEquals(instance.get(2).isOperator(),false);
        
        instance.parseFormula(instance.get(2).toString().substring(1));
        assertEquals(4,instance.size());
        assertTrue("Was: <"+instance.get(0).toString()+"> Expected: <c>",instance.get(0).toString().equals("c"));
        assertEquals(instance.get(0).isOperator(),false);
        assertTrue("Was: <"+instance.get(1).toString()+"> Expected: <||>",instance.get(1).toString().equals("||"));
        assertEquals(instance.get(1).isOperator(),true);
        assertEquals(FormulaVariable.testIsUnaryOperator(instance.get(1).getOperator()),false);
        assertTrue("Was: <"+instance.get(2).toString()+"> Expected: <!>",instance.get(2).toString().equals("!"));
        assertEquals(instance.get(2).isOperator(),true);
        assertEquals(FormulaVariable.testIsUnaryOperator(instance.get(2).getOperator()),true);
        assertTrue("Was: <"+instance.get(3).toString()+"> Expected: <D>",instance.get(3).toString().equals("D"));
        assertEquals(instance.get(3).isOperator(),false);
        
        formula="10*(6-2)+4";
        instance.parseFormula(formula);
        assertEquals(5,instance.size());
        assertEquals(FormulaVariable.TYPE_LONG,instance.get(0).getVariableType());
        assertEquals(10L,(long)instance.get(0).getLong());
        assertEquals(FormulaVariable.TYPE_OPERATOR_MULTIPLY,instance.get(1).getOperator());
        assertEquals(FormulaVariable.TYPE_FORMULA,instance.get(2).getVariableType());
        assertTrue("Was: <"+instance.get(2).toString()+"> Expected: <(6-2)>",instance.get(2).toString().equals("(6-2)"));
        assertEquals(FormulaVariable.TYPE_OPERATOR_PLUS,instance.get(3).getOperator());
        assertEquals(FormulaVariable.TYPE_LONG,instance.get(4).getVariableType());
        assertEquals(4L,(long)instance.get(4).getLong());
        
        
        error=false;
        parseMessage="";
        expectedMessage="There are two Operators in a row in this Formula: A| |B at index 3";
        try{
            formula="A| |B";
            instance.parseFormula(formula);
        } catch (java.text.ParseException ex){
            error=true;
            parseMessage=ex.getMessage();
        }
        assertTrue("Expected ParseException error",error);
        assertTrue("Was: <"+parseMessage+"> Expected: <"+expectedMessage+">",parseMessage.equals(expectedMessage));
        
        error=false;
        parseMessage="";
        expectedMessage="There are two Operators in a row in this Formula: *A+B at index 0";
        try{
            formula="*A+B";
            instance.parseFormula(formula);
        } catch (java.text.ParseException ex){
            error=true;
            parseMessage=ex.getMessage();
        }
        assertTrue("Expected ParseException error",error);
        assertTrue("Was: <"+parseMessage+"> Expected: <"+expectedMessage+">",parseMessage.equals(expectedMessage));
        
        formula="12.34+-11";
        instance.parseFormula(formula);
        assertEquals(3,instance.size());
        assertTrue("Was: <"+instance.get(0).getString()+"> Expected: <12.34>" ,instance.get(0).getString().equals("12.34"));
        assertEquals(FormulaVariable.TYPE_DOUBLE,instance.get(0).getVariableType());
        assertEquals(FormulaVariable.TYPE_OPERATOR_PLUS,instance.get(1).getOperator());
        assertTrue("Was: <"+instance.get(2).getString()+"> Expected: <-11.3>" ,instance.get(2).getString().equals("-11"));
        assertEquals(FormulaVariable.TYPE_LONG,instance.get(2).getVariableType());
        
        formula="\"This is +12/23 \\\" hello there\" + \"12\"";
        instance.parseFormula(formula);
        assertEquals(3,instance.size());
        assertTrue("Was: <"+instance.get(0).getString()+"> Expected: <This is +12/23 \" hello there>",instance.get(0).getString().equals("This is +12/23 \" hello there"));
        assertEquals(FormulaVariable.TYPE_STRING,instance.get(0).getVariableType());
        assertEquals(FormulaVariable.TYPE_OPERATOR_PLUS,instance.get(1).getOperator());
        assertTrue("Was: <"+instance.get(2).getString()+"> Expected: <12>",instance.get(2).getString().equals("12"));
        assertEquals(FormulaVariable.TYPE_STRING,instance.get(2).getVariableType());
        
        formula="\"This is\"+\" \"+\"a test.\"";
        instance.parseFormula(formula);
        assertEquals(5,instance.size());
        assertTrue("Was: <"+instance.get(0).getString()+"> Expected: <This is>",instance.get(0).getString().equals("This is"));
        assertEquals(FormulaVariable.TYPE_STRING,instance.get(0).getVariableType());
        assertEquals(FormulaVariable.TYPE_OPERATOR_PLUS,instance.get(1).getOperator());
        assertTrue("Was: <"+instance.get(2).getString()+"> Expected: < >",instance.get(2).getString().equals(" "));
        assertEquals(FormulaVariable.TYPE_STRING,instance.get(2).getVariableType());
        assertEquals(FormulaVariable.TYPE_OPERATOR_PLUS,instance.get(3).getOperator());
        assertTrue("Was: <"+instance.get(4).getString()+"> Expected: <a test.>",instance.get(4).getString().equals("a test."));
        assertEquals(FormulaVariable.TYPE_STRING,instance.get(4).getVariableType());
    }
    
    /**
     * Test of solveRangeOfValuesSeparatedBySameOperator method, of class com.accountingenhancements.formula.FormulaVariableStack
     */
    public void testSolveRangeOfValuesSeparatedBySameOperator()throws Exception{
        System.out.println("solveRangeOfValuesSeparatedBySameOperator");
        //public static FormulaVariable solveRangeOfValuesSeparatedBySameOperator
        //(ArrayList<FormulaVariable> stack, int startPointer, int endPointer, FormulaVariableList variableList, 
        //SupportParameters supportParameters, FormulaFunctionList functionList, int resolveEverythingAboveLevel)
        
        FormulaVariable result=null;
        ArrayList<FormulaVariable> stack=new ArrayList<FormulaVariable>();
        int startPointer;
        int endPointer;
        FormulaVariableList variableList=null;
        SupportParameters supportParameters=null;
        FormulaFunctionList functionList=null;
        int resolveEverythingAboveLevel=0;
        boolean error;
        
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_OR,0)); //Intentionally illegal, set here to test range portion
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_UNARY_NOT,0));
        stack.add(new FormulaVariable("",false,0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_AND,0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_UNARY_NOT,0));
        stack.add(new FormulaVariable("",false,0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_OR,0)); //Intentionally illegal, set here to test range portion
        
        result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,1,5,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        
        stack.clear();
        stack.add(new FormulaVariable("","Hi There.",0,false));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_PLUS,0));
        stack.add(new FormulaVariable(""," ",0,false));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_PLUS,0));
        stack.add(new FormulaVariable("","How are you?",0,false));
        result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,0,stack.size()-1,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.toString()+"> Expected: <Hi There. How are you?>",result.toString().equals("Hi There. How are you?"));
        stack.clear();
        stack.add(new FormulaVariable("",23L,0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_OR));
        stack.add((FormulaVariable)null);
        result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,0,stack.size()-1,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        stack.clear();
        stack.add(new FormulaVariable("",23L,0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_OR));
        stack.add(new FormulaVariable("",FormulaVariable.TYPE_LONG, 0));
        result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,0,stack.size()-1,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_BOOLEAN,result.getVariableType());
        assertEquals(true,result.getBoolean());
        stack.clear();
        stack.add(new FormulaVariable("",23L,0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_AND));
        stack.add((FormulaVariable)null);
        error=false;
        try{
            result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,0,stack.size()-1,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        stack.clear();
        stack.add(new FormulaVariable("",23L,0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_AND));
        stack.add(new FormulaVariable("",FormulaVariable.TYPE_LONG, 0));
        error=false;
        try{
            result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,0,stack.size()-1,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        stack.clear();
        stack.add((FormulaVariable)null);
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_OR));
        stack.add(new FormulaVariable("",23L,0));
        error=false;
        try{
            result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,0,stack.size()-1,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        stack.clear();
        stack.add(new FormulaVariable("",FormulaVariable.TYPE_LONG, 0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_OR));
        stack.add(new FormulaVariable("",23L,0));
        error=false;
        try{
            result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,0,stack.size()-1,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        stack.clear();
        stack.add(new FormulaVariable("",42L, 0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_PLUS));
        stack.add(new FormulaVariable("",23L,0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_PLUS));
        stack.add(new FormulaVariable("",12L,0));
        result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,0,stack.size()-1,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(77L,(long)result.getLong());
        stack.clear();
        stack.add(new FormulaVariable("",42L, 0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_MINUS));
        stack.add(new FormulaVariable("",23L,0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_MINUS));
        stack.add(new FormulaVariable("",12L,0));
        result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,0,stack.size()-1,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(7L,(long)result.getLong());
        stack.clear();
        stack.add(new FormulaVariable("",42L, 0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_PLUS));
        stack.add(new FormulaVariable("",23L,0));
        stack.add(new FormulaVariable(FormulaVariable.TYPE_OPERATOR_MINUS));
        stack.add(new FormulaVariable("",12L,0));
        error=false;
        try{
            result=FormulaVariableStack.solveRangeOfValuesSeparatedBySameOperator(stack,0,stack.size()-1,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
        } catch(java.lang.ArithmeticException ex){error=true;}
        assertEquals(true,error);
        
    }
    
    /**
     * Test of solve method, of class com.accountingenhancements.formula.FormulaVariableStack.
     */
    public void testSolve()throws Exception{
        System.out.println("solve");
        FormulaVariableStack instance = null;
        FormulaVariable result;
        FormulaVariableList variableList = new FormulaVariableList();
        
        instance = new FormulaVariableStack("\"This is a\"+\" \"+\"test.\"");
        result=instance.solve(null,0,null,null);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.toString()+"> Expected: <This is a test.>",result.toString().equals("This is a test."));
        
        instance = new FormulaVariableStack("23+12/2");
        result=instance.solve(null,0,null,null);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(29L,(long)result.getLong());
        
        instance = new FormulaVariableStack("23+12/2-10");
        result=instance.solve(null,0,null,null);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(19L,(long)result.getLong());
        
        instance = new FormulaVariableStack("23+12/2*2-10/2");
        result=instance.solve(null,0,null,null);
        assertEquals(FormulaVariable.TYPE_LONG,result.getVariableType());
        assertEquals(21L,(long)result.getLong());
        
        instance = new FormulaVariableStack("23.01+12/2*2-10/2");
        result=instance.solve(null,0,null,null);
        assertEquals(FormulaVariable.TYPE_DOUBLE,result.getVariableType());
        assertTrue("Was: <"+result.toString()+"> Expected: <21.01>",result.toString().equals("21.01"));
        
        instance = new FormulaVariableStack("23.01+(8/2)*(10-8/2)");
        result=instance.solve(null,0,null,null);
        assertEquals(FormulaVariable.TYPE_DOUBLE,result.getVariableType());
        assertTrue("Was: <"+result.toString()+"> Expected: <47.01>",result.toString().equals("47.01"));
        
        //variableList.addVariable(new FormulaVariable("EmpNum","001234567",FormulaVariable.TYPE_STRING,0,1));
        variableList.addValue("EmpNum","\"001234567\"",1,true);
        instance = new FormulaVariableStack("\"Employee Number: \"+empnum");
        result=instance.solve(variableList,0,null,null,0);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.toString()+"> Expected: <Employee Number: 001234567>",result.getString().equals("Employee Number: 001234567"));
        
        //Test levels
        instance=new FormulaVariableStack("A+B");
        variableList=new FormulaVariableList();
        FormulaVariable a=new FormulaVariable("a","Test_1",1,false);
        FormulaVariable b=new FormulaVariable("b"," Is OK",2,false);
        variableList.addVariable(a);
        variableList.addVariable(b);
        result=instance.solve(variableList,0,null,null,2);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.toString()+"> Expected: <Test_1 Is OK>",result.toString().equals("Test_1 Is OK"));
        a.setValue ("Test_2");
        result=instance.solve(variableList,0,null,null,2);
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.toString()+"> Expected: <Test_1 Is OK>",result.toString().equals("Test_1 Is OK"));
        result=instance.solve(variableList,0,null,null,1); //Even though this isn't supposed the level_1 changed, this recalculats because a level 2 variable exists.
        assertEquals(FormulaVariable.TYPE_STRING,result.getVariableType());
        assertTrue("Was: <"+result.toString()+"> Expected: <Test_2 Is OK>",result.toString().equals("Test_1 Is OK"));
        
    }
    
    /**
     * Test of clone method, of class com.accountingenhancements.formula.FormulaVariableStack.
     */
    public void testClone()throws Exception{
        System.out.println("clone");
        FormulaVariableStack instance;
        FormulaVariableStack original;
        
        String formula = "A + B(c||!D)";
        original = new FormulaVariableStack();
        original.parseFormula(formula);
        instance = original.clone();
        original.parseFormula("1+2=3");
        assertEquals(3,instance.size());
        assertTrue("Was: <"+instance.get(0).toString()+"> Expected: <A>",instance.get(0).toString().equals("A"));
        assertEquals(instance.get(0).isOperator(),false);
        assertTrue("Was: <"+instance.get(1).toString()+"> Expected: <+>",instance.get(1).toString().equals("+"));
        assertEquals(instance.get(1).isOperator(),true);
        assertTrue("Was: <"+instance.get(2).toString()+"> Expected: <B(c||!D)>",instance.get(2).toString().equals("B(c||!D)"));
        assertEquals(instance.get(2).isOperator(),false);
    }
    
    /**
     *Test of purgeResultsInStackGreaterThanSpecifiedLevel, of class com.accountingenhancements.formula.FormulaVariable
     */
    public void testPurgeResultsInStackGreaterThanSpecifiedLevel()throws Exception{
        System.out.println("purgeResultsInStackGreaterThanSpecifiedLevel");
        FormulaVariableStack instance;
        String formula = "A + B+(c||!D)";
        instance = new FormulaVariableStack();
        instance.parseFormula(formula);
        assertEquals("A",instance.get(0).toString());
        instance.get(0).highestLevel=1;
        instance.get(0).resolvedVariable=new FormulaVariable("",4L,1);
        assertEquals("B",instance.get(2).toString());
        instance.get(2).highestLevel=2;
        instance.get(2).resolvedVariable=new FormulaVariable("",5L,2);
        instance.get(4).stack=new FormulaVariableStack();
        instance.get(4).stack.parseFormula(instance.get(4).variableValue);
        instance.get(4).stack.highestLevelInSolution=3;
        instance.get(4).stack.result=new FormulaVariable("",6L,3);
        assertEquals("c",instance.get(4).stack.get(0).toString());
        instance.get(4).stack.get(0).highestLevel=4;
        instance.get(4).stack.get(0).resolvedVariable=new FormulaVariable("",7L,4);
        assertEquals("D",instance.get(4).stack.get(3).toString());
        instance.get(4).stack.get(3).highestLevel=5;
        instance.get(4).stack.get(3).resolvedVariable=new FormulaVariable("",8L,5);
        instance.purgeResultsInStackGreaterThanSpecifiedLevel(5);
        assertEquals(1,instance.get(0).highestLevel);
        assertEquals(4L,instance.get(0).resolvedVariable.getLong().longValue());
        assertEquals(2,instance.get(2).highestLevel);
        assertEquals(5L,instance.get(2).resolvedVariable.getLong().longValue());
        assertEquals(3,instance.get(4).stack.highestLevelInSolution);
        assertEquals(6L,instance.get(4).stack.result.getLong().longValue());
        assertEquals(4,instance.get(4).stack.get(0).highestLevel);
        assertEquals(7L,instance.get(4).stack.get(0).resolvedVariable.getLong().longValue());
        assertEquals(5,instance.get(4).stack.get(3).highestLevel);
        assertEquals(8L,instance.get(4).stack.get(3).resolvedVariable.getLong().longValue());
        instance.purgeResultsInStackGreaterThanSpecifiedLevel(4);
        assertEquals(1,instance.get(0).highestLevel);
        assertEquals(4L,instance.get(0).resolvedVariable.getLong().longValue());
        assertEquals(2,instance.get(2).highestLevel);
        assertEquals(5L,instance.get(2).resolvedVariable.getLong().longValue());
        assertEquals(3,instance.get(4).stack.highestLevelInSolution);
        assertEquals(6L,instance.get(4).stack.result.getLong().longValue());
        assertEquals(4,instance.get(4).stack.get(0).highestLevel);
        assertEquals(7L,instance.get(4).stack.get(0).resolvedVariable.getLong().longValue());
        assertEquals(-1,instance.get(4).stack.get(3).highestLevel);
        assertNull(instance.get(4).stack.get(3).resolvedVariable);
        instance.purgeResultsInStackGreaterThanSpecifiedLevel(2);
        assertEquals(1,instance.get(0).highestLevel);
        assertEquals(4L,instance.get(0).resolvedVariable.getLong().longValue());
        assertEquals(2,instance.get(2).highestLevel);
        assertEquals(5L,instance.get(2).resolvedVariable.getLong().longValue());
        assertEquals(-1,instance.get(4).stack.highestLevelInSolution);
        assertNull(instance.get(4).stack.result);
        assertEquals(-1,instance.get(4).stack.get(0).highestLevel);
        assertNull(instance.get(4).stack.get(0).resolvedVariable);
        assertEquals(-1,instance.get(4).stack.get(3).highestLevel);
        assertNull(instance.get(4).stack.get(3).resolvedVariable);
        instance.purgeResultsInStackGreaterThanSpecifiedLevel(1);
        assertEquals(1,instance.get(0).highestLevel);
        assertEquals(4L,instance.get(0).resolvedVariable.getLong().longValue());
        assertEquals(-1,instance.get(2).highestLevel);
        assertNull(instance.get(2).resolvedVariable);
        assertEquals(-1,instance.get(4).stack.highestLevelInSolution);
        assertNull(instance.get(4).stack.result);
        assertEquals(-1,instance.get(4).stack.get(0).highestLevel);
        assertNull(instance.get(4).stack.get(0).resolvedVariable);
        assertEquals(-1,instance.get(4).stack.get(3).highestLevel);
        assertNull(instance.get(4).stack.get(3).resolvedVariable);
        instance.purgeResultsInStackGreaterThanSpecifiedLevel(-1);
        assertEquals(0,instance.size());
        
    }
    
}