/*

     This file is part of Combean.

     Combean is free software; you can redistribute it and/or modify

     it under the terms of the GNU General Public License as published by

     the Free Software Foundation; either version 2 of the License, or

     (at your option) any later version.

     Combean is distributed in the hope that it will be useful,

     but WITHOUT ANY WARRANTY; without even the implied warranty of

     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License

     along with Foobar; if not, write to the Free Software

     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

 package net.sourceforge.combean.test.mathprog.grooml;

 import groovy.util.GroovyTestCase

 import net.sourceforge.combean.mathprog.grooml.GExpression;

 import net.sourceforge.combean.mathprog.grooml.GDynamicExpression;

 import net.sourceforge.combean.mathprog.grooml.GSimpleExpression;

 import net.sourceforge.combean.mathprog.grooml.GSumExpression;

 import net.sourceforge.combean.mathprog.grooml.GCombinedExpression;

 import net.sourceforge.combean.mathprog.grooml.GTerm;

 import net.sourceforge.combean.mathprog.grooml.GSet;

 class TestGExpression extends GroovyTestCase {

     private Object env;

     private GDynamicExpression simpleExp;

     final private String simpleExpAsString = "1.0 x[1]";  

     void setUp() {

         this.env = [:];

         this.simpleExp = new GDynamicExpression() { "x[1]" };

     }

     void testConstructFromString() {

         static final stringsForConstruction =

             [

                     ["2x[1]", "2.0 x[1]"],

                 ["x[1]", "1.0 x[1]"],

                 ["foo[]", "1.0 foo[]"],

                 ["   3.5  *   bar[  2 , 1 ]", "3.5 bar[2,1]"],

             ];

         stringsForConstruction.each{

             input, expected ->

             GExpression expr = new GSimpleExpression(input) 

             assertEquals(expected, expr.termsToString(env));

         }

     }

     private void checkTermsInExpr(GExpression expr, List termsAsStrings) {

                    Iterator exprIt = expr.evaluate(this.env);

                    def terms = exprIt.collect{ it.toString() };

                    terms.sort();

         assertArrayEquals(termsAsStrings.sort().toArray(), terms.toArray());

         }

     void testStringExpr() {

         GSimpleExpression strexp = new GSimpleExpression("-2 foo [3]");

         checkTermsInExpr(strexp, ["-2.0 foo[3]"]);

     }

     void testSimpleDynExpr() {

         GDynamicExpression dynexp = new GDynamicExpression() { "3.0 foo [3]" };

         checkTermsInExpr(dynexp, ["3.0 foo[3]"]);

     }

     void testDynExprEvaluation() {

         this.env = [c : 3.0, v:"foo", i:2];

         GDynamicExpression dynexp =

             new GDynamicExpression() { "$c $v[$i]" };

         checkTermsInExpr(dynexp, ["3.0 foo[2]"]);

     }

     void testEmptySum() {

         GSet s = GSet.convert(1..<1);

         GSumExpression sumExp = new GSumExpression([i: s], simpleExp);

         assertFalse(sumExp.evaluate(this.env).hasNext());

     }

     void testSumWithConstantExpression() {

         GSet s = GSet.convert(1..2);

         GSumExpression sumExp = new GSumExpression([i: s], simpleExp);

         checkTermsInExpr(sumExp, [simpleExpAsString, simpleExpAsString]);

     }

     void testSumWithVariableExpressionInClosure() {

         GDynamicExpression dynExp = new GDynamicExpression() { " ${2.5*bar} x[$bar]" };

         GSet s = GSet.convert(1..2);

         GSumExpression sumExp = new GSumExpression([bar: s], dynExp);

         checkTermsInExpr(sumExp, ["2.5 x[1]", "5.0 x[2]"]);

     }

     /** TODO: change delegate of GString

     void testSumWithVariableExpressionInGString() {

         Map env = [:];

         GSimpleExpression strExp = new GSimpleExpression(" ${2.5*bar} x[$bar]", env);

         GSet s = GSet.convert(1..2);

         GSumExpression sumExp = new GSumExpression([bar: s], strExp, env);

         assertTrue(sumExp.hasNext());

         GTerm t = sumExp.next();

         assertToString(t, "2.5 x[1]");

         assertTrue(sumExp.hasNext());

         t = sumExp.next();

         assertToString(t, "5.0 x[2]");

         assertFalse(sumExp.hasNext());

     }

     */

     void testNestedSums() {

         GDynamicExpression dynExp = new GDynamicExpression() { " ${i+j} x[$i,$j]" };

         GSet rangeI = GSet.convert(1..2);

         GSet rangeJ = GSet.convert(2..3);

         GSumExpression innerSum = new GSumExpression([j: rangeJ], dynExp);

         GSumExpression outerSum = new GSumExpression([i: rangeI], innerSum);

         checkTermsInExpr(outerSum, ["3.0 x[1,2]",

                                     "4.0 x[1,3]",

                                     "4.0 x[2,2]",

                                     "5.0 x[2,3]"]);

     }

     void testMultiIndexSum() {

         GDynamicExpression dynExp = new GDynamicExpression() { " ${i+j} x[$i,$j]" };

         GSet rangeI = GSet.convert(1..2);

         GSet rangeJ = GSet.convert(2..3);

         GSumExpression outerSum =

             new GSumExpression([j: rangeJ, i:rangeI], dynExp);

         checkTermsInExpr(outerSum, ["3.0 x[1,2]",

                                     "4.0 x[1,3]",

                                     "4.0 x[2,2]",

                                     "5.0 x[2,3]"]);

     }

     void testCombinedExpressions() {

         GSimpleExpression strExp1 = new GSimpleExpression("1.0 x[1]");

         GSimpleExpression strExp2 = new GSimpleExpression("2.0 x[2]");

         GCombinedExpression combExp =

             new GCombinedExpression([strExp1, strExp2]);

         checkTermsInExpr(combExp, ["1.0 x[1]", "2.0 x[2]"]);

     }

 }