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

package geniusweb.profile.utilityspace;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
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.List;
import java.util.Map;

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.DiscreteValueSet;
import geniusweb.issuevalue.NumberValue;
import geniusweb.issuevalue.NumberValueSet;
import geniusweb.issuevalue.ValueSet;
import tudelft.utilities.junit.GeneralTests;

public class DiscreteValueSetUtilitiesTest
                extends GeneralTests<DiscreteValueSetUtilities> {

        private final static DiscreteValue vala = new DiscreteValue("a");
        private final static DiscreteValue vala1 = new DiscreteValue("a");
        private final static DiscreteValue valb = new DiscreteValue("b");
        private final static NumberValue valn = new NumberValue("99");

        private final static BigDecimal util = new BigDecimal("0.14");
        private final static BigDecimal util1 = new BigDecimal("0.14");
        private final static BigDecimal utilb = new BigDecimal("0.37");

        private final static BigDecimal badutil = new BigDecimal("1.37");
        private final static BigDecimal badutil2 = new BigDecimal("-0.37");

        private final static DiscreteValueSetUtilities utils, utils1, utilsb,
                        utils1b, utilsc1, utilsc2;
        private static final ObjectMapper jackson = new ObjectMapper();

        static {
                Map<DiscreteValue, BigDecimal> valueUtils = new HashMap<>();
                Map<DiscreteValue, BigDecimal> valueUtils1 = new HashMap<>();
                Map<DiscreteValue, BigDecimal> valueUtilsb = new HashMap<>();
                Map<DiscreteValue, BigDecimal> valueUtils1b = new HashMap<>();

                Map<DiscreteValue, BigDecimal> valueUtilsc1 = new HashMap<>();
                Map<DiscreteValue, BigDecimal> valueUtilsc2 = new HashMap<>();

                valueUtils.put(vala, util);
                valueUtils1.put(vala1, util1); // same value and utility
                valueUtilsb.put(valb, utilb); // different value and utility
                valueUtils1b.put(vala, utilb); // same value, different utility.

                valueUtilsc1.put(vala, util1);
                valueUtilsc1.put(valb, utilb);

                valueUtilsc1.put(valb, utilb);
                valueUtilsc1.put(vala1, util1);

                utils = new DiscreteValueSetUtilities(valueUtils);
                utils1 = new DiscreteValueSetUtilities(valueUtils1);
                utilsb = new DiscreteValueSetUtilities(valueUtilsb);
                utils1b = new DiscreteValueSetUtilities(valueUtils1b);

                utilsc1 = new DiscreteValueSetUtilities(valueUtilsc1);
                utilsc2 = new DiscreteValueSetUtilities(valueUtilsc1);
        }

        @Override
        public List<List<DiscreteValueSetUtilities>> getGeneralTestData() {
                return Arrays.asList(Arrays.asList(utils, utils1),
                                Arrays.asList(utilsb), Arrays.asList(utils1b),
                                Arrays.asList(utilsc1, utilsc2));
        }

        @Override
        public List<String> getGeneralTestStrings() {
                return Arrays.asList("DiscreteValueSetUtilities\\{\"a\"=0.14\\}",
                                "DiscreteValueSetUtilities\\{\"b\"=0.37\\}",
                                "DiscreteValueSetUtilities\\{\"a\"=0.37\\}",
                                "DiscreteValueSetUtilities\\{\"a\"=0.14, \"b\"=0.37\\}");
        }

        @SuppressWarnings("unused")
        @Test
        public void smokeTest() {
                Map<DiscreteValue, BigDecimal> valueUtils = new HashMap<>();
                new DiscreteValueSetUtilities(valueUtils);
        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testTooLargeUtility() {
                Map<DiscreteValue, BigDecimal> valueUtils = new HashMap<>();
                valueUtils.put(vala, util);
                valueUtils.put(valb, badutil);
                new DiscreteValueSetUtilities(valueUtils);
        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testNegativeUtility() {
                Map<DiscreteValue, BigDecimal> valueUtils = new HashMap<>();
                valueUtils.put(vala, util);
                valueUtils.put(valb, badutil2);
                new DiscreteValueSetUtilities(valueUtils);
        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testNullUtility() {
                Map<DiscreteValue, BigDecimal> valueUtils = new HashMap<>();
                valueUtils.put(vala, null);
                valueUtils.put(valb, util);
                new DiscreteValueSetUtilities(valueUtils);
        }

        @SuppressWarnings("unused")
        @Test(expected = NullPointerException.class)
        public void testNullValueUtils() {
                new DiscreteValueSetUtilities(null);

        }

        @SuppressWarnings("unused")
        @Test(expected = NullPointerException.class)
        public void testNullIssue() {
                Map<DiscreteValue, BigDecimal> valueUtils = new HashMap<>();
                valueUtils.put(vala, util);
                valueUtils.put(null, utilb);
                new DiscreteValueSetUtilities(valueUtils);
        }

        @Test
        public void testGetUtility() {
                Map<DiscreteValue, BigDecimal> valueUtils = new HashMap<>();
                valueUtils.put(vala, util);
                valueUtils.put(valb, utilb);
                DiscreteValueSetUtilities utilset = new DiscreteValueSetUtilities(
                                valueUtils);
                assertEquals(util, utilset.getUtility(vala));
                assertEquals(utilb, utilset.getUtility(valb));
                assertEquals(BigDecimal.ZERO,
                                utilset.getUtility(new DiscreteValue("unknownIssue")));

        }

        @Test
        public void testIsFitting() {
                ValueSet valueset = new DiscreteValueSet(Arrays.asList(vala, valb));

                Map<DiscreteValue, BigDecimal> valueUtils = new HashMap<>();
                valueUtils.put(vala, util);
                DiscreteValueSetUtilities utilset = new DiscreteValueSetUtilities(
                                valueUtils);

                assertEquals(
                                "The values in the set DiscreteValueSet[\"a\", \"b\"] do not match the values mapped to utilities [\"a\"]",
                                utilset.isFitting(valueset));

                valueUtils.put(valb, utilb);
                utilset = new DiscreteValueSetUtilities(valueUtils);
                assertEquals(null, utilset.isFitting(valueset));

                valueUtils.put(new DiscreteValue("unknownIssue"), util1);
                utilset = new DiscreteValueSetUtilities(valueUtils);
                assertEquals(
                                "The values in the set DiscreteValueSet[\"a\", \"b\"] do not match the values mapped to utilities [\"a\", \"b\", \"unknownIssue\"]",
                                utilset.isFitting(valueset));

        }

        @Test
        public void testIsFittingWrongType() {
                ValueSet valueset = new NumberValueSet(BigDecimal.ZERO, BigDecimal.ONE,
                                new BigDecimal("0.3"));

                Map<DiscreteValue, BigDecimal> valueUtils = new HashMap<>();
                valueUtils.put(vala, util);
                valueUtils.put(valb, utilb);
                DiscreteValueSetUtilities utilset = new DiscreteValueSetUtilities(
                                valueUtils);

                assertEquals(
                                "The utilities are for a discrete valueset but the given values are numberValueSet[0,1,0.3]",
                                utilset.isFitting(valueset));

        }

        @Test
        public void testIsFittingWrongIssues()
                        throws JsonParseException, JsonMappingException, IOException {
                // Notice, party tent has extra single quote in the valuesstr.
                String valuesstr = "{\"values\": [\"Party Tent'\",\"Your Dorm\", \"Party Room\", \"Ballroom\" ]}";
                String utilstring = "{\"DiscreteValueSetUtilities\": {\"valueUtilities\": {\"Party Tent\": 0.52,\"Your Dorm\": 0.23,\"Party Room\": 0.99,\"Ballroom\": 0.77}}}";
                ValueSetUtilities valueutils = jackson.readValue(utilstring,
                                ValueSetUtilities.class);
                ValueSet values = jackson.readValue(valuesstr, ValueSet.class);
                System.out.println(valueutils.isFitting(values));
                assertFalse(valueutils.isFitting(values).isEmpty());

        }

        @Test
        public void testDeserializeAsDiscrete()
                        throws JsonParseException, JsonMappingException, IOException {
                // Check that DiscreteValueSetUtilities properly deserializes
                // discreteutils.
                String utilstring = "{\"DiscreteValueSetUtilities\": {\"valueUtilities\": {\"Party Tent\": 0.52,\"Your Dorm\": 0.23,\"Party Room\": 0.99,\"Ballroom\": 0.77}}}";
                DiscreteValueSetUtilities valueutils = jackson.readValue(utilstring,
                                DiscreteValueSetUtilities.class);
                assertTrue(new BigDecimal("0.23").compareTo(
                                valueutils.getUtility(new DiscreteValue("Your Dorm"))) == 0);

        }

}