source: profile/src/test/java/geniusweb/profile/utilityspace/PartsUtilitiesTest.java@ 52

package geniusweb.profile.utilityspace;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.junit.Before;
import org.junit.Test;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import geniusweb.issuevalue.DiscreteValue;
import geniusweb.issuevalue.Value;
import tudelft.utilities.junit.GeneralTests;

public class PartsUtilitiesTest extends GeneralTests<PartsUtilities> {
        private static final String iss2 = "issue2";

        private static final String iss1 = "issue1";

        private final ObjectMapper jackson = new ObjectMapper();

        private static BigDecimal N01 = new BigDecimal("0.1"),
                        N02 = new BigDecimal("0.2"), N03 = new BigDecimal("0.3"),
                        N05 = new BigDecimal("0.5"), N07 = new BigDecimal("0.7"),
                        N08 = new BigDecimal("0.8"), N09 = new BigDecimal("0.9");
        private final static DiscreteValue low = new DiscreteValue("low");
        private final static DiscreteValue high = new DiscreteValue("high");

        private final static String jsontext = "{\"PartsUtilities\":{\"issues\":[\"issue1\",\"issue2\"],\"utilslist\":[{\"values\":[\"low\",\"low\"],\"util\":0.3},{\"values\":[\"high\",\"high\"],\"util\":0.9}]}}";

        private PartsUtilities parts1, parts1a, parts2, parts3;

        @Before
        public void before() {
                List<PartUtil> vals = new LinkedList<>();
                vals.add(new PartUtil(Arrays.asList(low, low), N03));
                vals.add(new PartUtil(Arrays.asList(high, high), N09));
                List<PartUtil> vals1 = new LinkedList<>();
                vals1.add(new PartUtil(Arrays.asList(low, low), N09));
                List<String> issues = Arrays.asList(iss1, iss2);
                parts1 = new PartsUtilities(issues, vals);
                parts1a = new PartsUtilities(issues, vals);
                parts2 = new PartsUtilities(Arrays.asList(iss1), vals);
                parts3 = new PartsUtilities(issues, vals1);
        }

        @Override
        public List<List<PartsUtilities>> getGeneralTestData() {
                return Arrays.asList(Arrays.asList(parts1, parts1a),
                                Arrays.asList(parts2), Arrays.asList(parts3));
        }

        @Override
        public List<String> getGeneralTestStrings() {
                return Arrays.asList(
                                "PartsUtilities..issue1, issue2.,\\{.\"low\", \"low\".=0.3, .\"high\", \"high\".=0.9\\}.",
                                "PartsUtilities..issue1.,\\{.\"low\", \"low\".=0.3, .\"high\", \"high\".=0.9\\}.",
                                "PartsUtilities..issue1, issue2.,\\{.\"low\", \"low\".=0.9\\}.");
        }

        @Test(expected = IllegalArgumentException.class)
        public void testWeightsTooHigh() {
                Map<ProductOfValue, BigDecimal> utils = new HashMap<>();
                utils.put(new ProductOfValue(Arrays.asList(low, low)),
                                new BigDecimal("1.1"));
                new PartsUtilities(Arrays.asList(iss1, iss2), utils);
        }

        @Test(expected = IllegalArgumentException.class)
        public void testWeightsTooLow() {
                Map<ProductOfValue, BigDecimal> utils = new HashMap<>();
                utils.put(new ProductOfValue(Arrays.asList(low, low)),
                                new BigDecimal("-0.3"));
                new PartsUtilities(Arrays.asList(iss1, iss2), utils);
        }

        @Test
        public void testBasicSerialize()
                        throws JsonParseException, JsonMappingException, IOException {
                System.out.println(jsontext);
                assertEquals(jsontext, jackson.writeValueAsString(parts1));
        }

        @Test
        public void testBasicDeserialize()
                        throws JsonParseException, JsonMappingException, IOException {
                System.out.println(jsontext);
                assertEquals(parts1, jackson.readValue(jsontext, PartsUtilities.class));
        }

        @Test
        public void testGetUtility() {
                assertEquals(N03,
                                parts1.getUtility(new ProductOfValue(Arrays.asList(low, low))));
                assertEquals(N09, parts1
                                .getUtility(new ProductOfValue(Arrays.asList(high, high))));
                assertEquals(BigDecimal.ZERO, parts1
                                .getUtility(new ProductOfValue(Arrays.asList(low, high))));
        }

        @Test
        public void testGetIssues() {
                assertEquals(Arrays.asList(iss1, iss2), parts1.getIssues());
        }

        @Test
        public void testGetIncorrectValue() {
                assertEquals(BigDecimal.ZERO, parts1.getUtility(low));
        }

        @Test
        public void testGetValue() {
                assertTrue(N03.compareTo(parts1
                                .getUtility(new ProductOfValue(Arrays.asList(low, low)))) == 0);
        }

        @Test
        public void testMerge() {
                Map<ProductOfValue, BigDecimal> extravals = new HashMap<>();
                extravals.put(new ProductOfValue(Arrays.asList(low, low)),
                                N01.multiply(N05));
                extravals.put(new ProductOfValue(Arrays.asList(high, high)),
                                N01.multiply(N07));
                PartsUtilities extraparts = new PartsUtilities(
                                Arrays.asList("extra1", "extra2"), extravals);

                PartsUtilities merged = parts1.add(extraparts);

                Value pval = new ProductOfValue(Arrays.asList(low, low, high, high));
                assertEquals(0,
                                N03.add(N01.multiply(N07)).compareTo(merged.getUtility(pval)));
        }

}