/*

     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.GSet;

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

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

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

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

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

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

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

 import net.sourceforge.combean.except.GModelException;

 class TestGSet extends GroovyTestCase {

     /**

      * List set specific tests

      */

     public void testIntegerRangeSet() {

         Range r = 1..10;

         GSet s = new GListSet(r);

         assertTrue(s.isNumbered());

         auxTestList(r, s);

     }

     public void testEmptyRangeSet() {

         GListSet s = new GListSet(1..<1);

         assertTrue(s.isNumbered());

         assertEquals(0, s.size());

         assertFalse(s.evaluate([:]).hasNext());

     }

     public void testGetElemInRangeSet() {

         GListSet s = new GListSet(10..15);

         for (it in 0..5) {

                 assertEquals(10 + it, s.getElem(it));

         }

     }

     public void testStringListSet() {

         List l = ["foo", "bar", "bla"];

         GListSet s = new GListSet(l);

         assertTrue(s.isNumbered());

         auxTestList(l, s);

     }

     public void testEmptyListSet() {

         GListSet s = new GListSet([]);

         assertTrue(s.isNumbered());

         assertEquals(0, s.size());

         assertFalse(s.evaluate([:]).hasNext());

     }

     /**

      * Product set specific tests

      */

     public void testProductSet() {

         GProductSet s = new GProductSet([1..2, 3..4]);

         assertTrue(s.isNumbered());

         assertEquals(4, s.size());

         assertEquals(2, s.indexOf([2,3]));

         assertToString(s.getElem(1), "[1, 4]");

         auxTestList([[1,3], [1,4], [2,3], [2,4]], s);

     }

     public void testProductOfSingleElements() {

         GProductSet s = new GProductSet([1..1, 2..2]);

         assertEquals(1, s.size());

         assertEquals(0, s.indexOf([1,2]));

         assertToString(s.getElem(0), "[1, 2]");

         auxTestList([[1,2]], s);

     }

     public void testProductWithSingleElement() {

         GProductSet s = new GProductSet([1..2, 3..3]);

         assertEquals(2, s.size());

         assertEquals(1, s.indexOf([2,3]));

         assertToString(s.getElem(0), "[1, 3]");

         auxTestList([[1,3],[2,3]], s);

     }

     public void testEmptyProductSet() {

         shouldFail(GModelException) {

                 GProductSet s = new GProductSet([1..2, [], 3..4]);

         }

     }

     /**

      * Tests for nested and dynamic sets

      */

      public void testDynamicSet() {

          GSet s = new GDynamicSet() { 1..i };

          assertFalse(s.isNumbered());

          auxTestList([1, 2, 3], s, [i:3]);

      }

     public void testNestedDynamicSet() {

         GSet outer = new GIndexBinding(i:1..2);

         GSet inner = new GDynamicSet() { 1..i };

         GSet s = new GNestedSet(outer, inner);

         assertFalse(s.isNumbered());

         auxTestList([[1,1], [2,1], [2,2]], s);

     }

     /**

      * Tests for conversion of set definition

      */

     public void testConvertToListSet() {

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

         assertTrue(s instanceof GListSet);

         auxTestList(1..2, s);

         s = GSet.convert(["a", "b"]);

         assertTrue(s instanceof GListSet);

         auxTestList(["a", "b"], s);

         }

     public void testConvertToListSetWithSingleElement() {

         GSet s = GSet.convert(1);

         assertTrue(s instanceof GListSet);

         auxTestList([1], s);

         s = GSet.convert("a");

         assertTrue(s instanceof GListSet);

         auxTestList(["a"], s);

         }

     public void testConvertMapToBinding() {

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

         assertTrue(s instanceof GIndexBinding);

         auxTestList([1,2], s);

         s = GSet.convert(i:1..2, j:3..4);

         assertTrue(s instanceof GIndexBinding);

         auxTestList([[1,3],[1,4],[2,3],[2,4]], s);

         }

     public void testMultiplyOperator() {

         GSet prod = null;

         prod = GSet.convert(1..2) * GSet.convert(3..4);

         auxTestList([[1,3], [1,4], [2,3], [2,4]], prod);

         prod = GSet.convert(1..1) * GSet.convert(3..3);

         auxTestList([[1,3]], prod);

         prod = GSet.convert(1..2) * GSet.convert(3..4) * GSet.convert(["x"]);

         auxTestList([[1,3,"x"], [1,4,"x"], [2,3,"x"], [2,4,"x"]], prod);

         prod = GSet.convert(["x"]) * GSet.convert(1..2) * GSet.convert(3..4);

         auxTestList([["x",1,3], ["x",1,4], ["x",2,3], ["x",2,4]], prod);

         prod = GSet.convert(["x"]) * (GSet.convert(1..2) * GSet.convert(3..4));

         auxTestList([["x",1,3], ["x",1,4], ["x",2,3], ["x",2,4]], prod);

         prod = GSet.convert(1..2) * (3..4);

         auxTestList([[1,3], [1,4], [2,3], [2,4]], prod);

         use (GModelArithmeticCategory) {

             prod = (1..2) * (3..4);

             auxTestList([[1,3], [1,4], [2,3], [2,4]], prod);

             prod = (1..2) * ["a", "b"];

             auxTestList([[1,"a"], [1,"b"], [2,"a"], [2,"b"]], prod);

         }

     }

     /**

      * Tests for index bindings used as sets

      */

     public void testProductOfBindingWithSimpleSet() {

         GIndexBinding bind = GIndexBinding.convert(i:1..2);

         GSet prod = bind * (3..4);

         auxTestList([[1,3], [1,4], [2,3], [2,4]], prod);

         GSet prodReverse = GSet.convert(3..4) * [i:1..2];

         auxTestList([[3,1], [3,2], [4,1], [4,2]], prodReverse);

     }

     public void testProductOfBindingWithDynamicSet() {

         GIndexBinding bind = GIndexBinding.convert(i:1..2);

         GSet prod = bind * {(1..i)};

         auxTestList([[1,1], [2,1], [2,2]], prod);

     }

     public void testCreateFromClosure() {

         GSet s = GSet.convert{ (1..i) * ["a", "b"] };

         assertTrue(s instanceof GDynamicSet);

         auxTestList([[1,"a"], [1,"b"], [2,"a"], [2,"b"]], s, [i:2]);

     }

     private void auxTestList(expectedValues, GSet setToTest, Object env=[:]) {

         for (iter in [1, 2]) {

             Iterator setIter = setToTest.evaluate(env);

                 expectedValues.each {

                     assertTrue(setIter.hasNext());

                     def nextVal = setIter.next();

                     assertEquals(it, nextVal);

                 }

                 assertFalse(setIter.hasNext());

         }

     }

 }