LeafTest.java

/*******************************************************************************
 * Copyright 2006 - 2012 Vienna University of Technology,
 * Department of Software Technology and Interactive Systems, IFS
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/
package eu.scape_project.planning.model.tree;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;

import eu.scape_project.planning.model.Alternative;
import eu.scape_project.planning.model.SampleAggregationMode;
import eu.scape_project.planning.model.Values;
import eu.scape_project.planning.model.scales.FloatScale;
import eu.scape_project.planning.model.scales.IntegerScale;
import eu.scape_project.planning.model.scales.OrdinalScale;
import eu.scape_project.planning.model.transform.NumericTransformer;
import eu.scape_project.planning.model.transform.OrdinalTransformer;
import eu.scape_project.planning.model.values.IntegerValue;
import eu.scape_project.planning.model.values.Value;

public class LeafTest {

    @Test
    @Ignore("True, a leaf should not be able to have children, but moving the list to Node would require massive changes.")
    public void test_Leaf_Can_Not_Contain_Children() {
        Leaf l1 = new Leaf();
        Leaf l2 = new Leaf();

        Leaf testLeaf = new Leaf();

        List<TreeNode> list = new ArrayList<TreeNode>();
        list.add(l1);
        list.add(l2);

        testLeaf.setChildren(list);
        Assert.assertTrue(testLeaf.getChildren().size() == 0);
    }

    public void testResetValues_List_Equals_Null() {

    }

    @Test
    public void testResetValues_Scale_Equals_Null() {
        Leaf l = new Leaf();
        Map<String, Values> map = new HashMap<String, Values>();
        map.put("test", new Values());
        l.setValueMap(map);
        Assert.assertTrue(l.getValueMap().size() == 1);
        l.resetValues(null);
        Assert.assertTrue(l.getValueMap().size() == 0);
    }

    @Test
    public void testResetValues_Different_Scale_In_Alternatives() {
        Leaf l = new Leaf();
        l.setScale(new FloatScale());
        Alternative a = new Alternative("test", "test");
        List<Alternative> alternatives = new ArrayList<Alternative>();
        alternatives.add(a);

        Map<String, Values> map = new HashMap<String, Values>();
        Value v1 = new IntegerValue();
        v1.setScale(new IntegerScale());
        Values values = new Values();
        values.add(v1);
        map.put("test", values);
        l.setValueMap(map);
        Assert.assertTrue(l.getValueMap().size() == 1);
        l.resetValues(alternatives);
        Assert.assertTrue(l.getValueMap().size() == 0);
    }

    @Test
    public void testSetDefaultTransformer_Scale_Equals_Null() {
        Leaf l = new Leaf();
        l.setDefaultTransformer();
        Assert.assertTrue(l.getTransformer() == null);
    }

    @Test
    public void testSetDefaultTransformer_Scale_Equals_Ordinal() {
        OrdinalScale o = new OrdinalScale();
        o.setRestriction("GOD/BAD/HORRIBLE");
        Leaf l = new Leaf();
        l.setScale(o);
        l.setDefaultTransformer();
        Assert.assertTrue(l.getTransformer() instanceof OrdinalTransformer);
        OrdinalTransformer ord = (OrdinalTransformer) l.getTransformer();
        Assert.assertTrue(ord.getMapping().containsKey("GOD"));
        Assert.assertTrue(ord.getMapping().containsKey("BAD"));
        Assert.assertTrue(ord.getMapping().containsKey("HORRIBLE"));
    }

    @Test
    public void testSetDefaultTransformer_Scale_Equals_NonOrdinal() {
        FloatScale o = new FloatScale();
        Leaf l = new Leaf();
        l.setScale(o);
        l.setDefaultTransformer();
        Assert.assertTrue(l.getTransformer() instanceof NumericTransformer);
    }

    public void testChangeScale_Scale_Equals_Null() {

    }

    @Test
    public void testChangeScale_Scale_Not_Null() {
        OrdinalScale ord = new OrdinalScale();
        Leaf l = new Leaf();
        l.changeScale(ord);
        Assert.assertFalse(l.getScale() == ord); // it is a clone
        Assert.assertTrue(l.getAggregationMode().equals(SampleAggregationMode.WORST));
    }

    @Test
    public void testRemoveValues() {
        Leaf l = new Leaf();
        Alternative a = new Alternative("test", "test");
        List<Alternative> alternatives = new ArrayList<Alternative>();
        alternatives.add(a);

        Map<String, Values> map = new HashMap<String, Values>();
        Value v1 = new IntegerValue();
        Value v2 = new IntegerValue();
        Value v3 = new IntegerValue();
        v1.setScale(new IntegerScale());
        Values values = new Values();
        values.add(v1);
        values.add(v2);
        values.add(v3);
        map.put("test", values);
        l.setValueMap(map);
        Assert.assertTrue(l.getValueMap().get("test").size() == 3);
        l.removeValues(alternatives, 1);
        Assert.assertTrue(l.getValueMap().get("test").size() == 2);
        Assert.assertTrue(!l.getValueMap().get("test").getList().contains(v2));
        l.removeValues(alternatives, 1);
        Assert.assertTrue(l.getValueMap().get("test").size() == 1);
        Assert.assertTrue(!l.getValueMap().get("test").getList().contains(v3));
    }

    public void testInitValues() {

    }

    @Test
    public void testRemoveLooseValues() {
        List<String> list = new ArrayList<String>();
        list.add("test1");
        list.add("test2");

        Leaf l = new Leaf();
        // l.setScale(new FloatScale());
        // Alternative a = new Alternative();
        // List<Alternative> alternatives = new ArrayList<Alternative>();
        // alternatives.add(a);
        // a.setName("test");
        Map<String, Values> map = new HashMap<String, Values>();
        Value v1 = new IntegerValue();
        v1.setScale(new IntegerScale());
        Values values1 = new Values();
        values1.add(v1);
        map.put("test1", values1);
        Value v2 = new IntegerValue();
        v2.setScale(new IntegerScale());
        Values values2 = new Values();
        values2.add(v2);
        map.put("test2", values2);
        Value v3 = new IntegerValue();
        v3.setScale(new IntegerScale());
        Values values3 = new Values();
        values3.add(v3);
        map.put("test3", values3);
        l.setValueMap(map);
        l.removeLooseValues(list, 5);
        Map<String, Values> res = l.getValueMap();
        Assert.assertTrue(res.containsKey("test1"));
        Assert.assertTrue(res.containsKey("test2"));
        Assert.assertFalse(res.containsKey("test3"));
    }
}