source: profile/src/test/java/geniusweb/profile/utilityspace/LinearAdditiveTest.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 static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

import org.junit.Test;

import com.fasterxml.jackson.databind.ObjectMapper;

import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.DiscreteValue;
import geniusweb.issuevalue.DiscreteValueSet;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.NumberValue;
import geniusweb.issuevalue.Value;
import geniusweb.issuevalue.ValueSet;
import tudelft.utilities.junit.GeneralTests;

public class LinearAdditiveTest
                extends GeneralTests<LinearAdditiveUtilitySpace> {
        private static final String NAME = "test";
        private static LinearAdditiveUtilitySpace utilspace1, utilspace1a,
                        utilspace2a, utilspace2b, utilspace3;
        private static Bid reservationBid;
        private static Bid reservationBid2;
        private static final BigDecimal I1V1UTIL = new BigDecimal("0.3");
        private static final BigDecimal I1V2UTIL = new BigDecimal("0.2");
        private static final BigDecimal I2V1UTIL = new BigDecimal("0.6");
        private static final BigDecimal I2V2UTIL = new BigDecimal("0.8");
        private static final BigDecimal WEIGHT1 = new BigDecimal("0.4");
        private static final BigDecimal WEIGHT2 = new BigDecimal("0.6");
        private static final Map<String, ValueSetUtilities> utils;
        private static final Map<String, BigDecimal> weights;
        private static final String ISS1 = "issue1";
        private static final String ISS2 = "issue2";
        private static final String ISS3 = "issue3";
        private static final DiscreteValue i1v1 = new DiscreteValue("issue1value1");
        private static final DiscreteValue i1v2 = new DiscreteValue("issue1value2");
        private static final DiscreteValue i2v1 = new DiscreteValue("issue2value1");
        private static final DiscreteValue i2v2 = new DiscreteValue("issue2value2");
        private static final DiscreteValue i3v1 = new DiscreteValue("issue3value1");
        private static final DiscreteValue i3v2 = new DiscreteValue("issue3value2");

        private static final Domain smalldomain, domain;

        private static final ValueSetUtilities value1Utils;
        private static final ObjectMapper jackson = new ObjectMapper();

        static {
                BigDecimal WEIGHT1a = new BigDecimal("0.3");
                BigDecimal WEIGHT2a = new BigDecimal("0.7");

                Map<String, ValueSet> values = new HashMap<>();
                values.put(ISS1, new DiscreteValueSet(Arrays.asList(i1v1, i1v2)));
                smalldomain = new Domain(NAME, values);
                values.put(ISS2, new DiscreteValueSet(Arrays.asList(i2v1, i2v2)));
                domain = new Domain(NAME, values);

                // build utilspace for string and equals testing.
                utils = new HashMap<>();
                Map<DiscreteValue, BigDecimal> valueUtils = new HashMap<>();
                valueUtils.put(i1v1, I1V1UTIL);
                valueUtils.put(i1v2, I1V2UTIL);
                value1Utils = new DiscreteValueSetUtilities(valueUtils);
                utils.put(ISS1, value1Utils);
                valueUtils = new HashMap<>();
                valueUtils.put(i2v1, I2V1UTIL);
                valueUtils.put(i2v2, I2V2UTIL);
                ValueSetUtilities value2Utils = new DiscreteValueSetUtilities(
                                valueUtils);
                utils.put(ISS2, value2Utils);

                // build utilspaceb, mix up the utilities a bit.
                Map<String, ValueSetUtilities> utilsb = new HashMap<>();
                valueUtils = new HashMap<>();
                valueUtils.put(i1v1, I2V1UTIL);
                valueUtils.put(i1v2, I2V2UTIL);
                DiscreteValueSetUtilities value1UtilsB = new DiscreteValueSetUtilities(
                                valueUtils);
                utilsb.put(ISS1, value1UtilsB);
                valueUtils = new HashMap<>();
                valueUtils.put(i2v1, I1V1UTIL);
                valueUtils.put(i2v2, I1V2UTIL);
                ValueSetUtilities value2UtilsB = new DiscreteValueSetUtilities(
                                valueUtils);
                utilsb.put(ISS2, value2UtilsB);

                // weight map
                weights = new HashMap<>();
                weights.put(ISS1, WEIGHT1);
                weights.put(ISS2, WEIGHT2);

                // weight map 2
                Map<String, BigDecimal> weightsb = new HashMap<>();
                weightsb.put(ISS1, WEIGHT1a);
                weightsb.put(ISS2, WEIGHT2a);

                // bid with lowest utility
                Map<String, Value> issuevalues = new HashMap<>();
                issuevalues.put(ISS1, i1v2);
                issuevalues.put(ISS2, i2v1);
                reservationBid = new Bid(issuevalues);

                issuevalues = new HashMap<>();
                issuevalues.put(ISS1, i1v1);
                issuevalues.put(ISS2, i2v1);
                reservationBid2 = new Bid(issuevalues);

                // make the utilspaces
                utilspace1 = new LinearAdditiveUtilitySpace(domain, NAME, utils,
                                weights, reservationBid);
                utilspace1a = new LinearAdditiveUtilitySpace(domain, NAME, utils,
                                weights, reservationBid);

                utilspace2a = new LinearAdditiveUtilitySpace(domain, NAME, utils,
                                weightsb, reservationBid);
                utilspace2b = new LinearAdditiveUtilitySpace(domain, NAME, utilsb,
                                weights, reservationBid);
                utilspace3 = new LinearAdditiveUtilitySpace(domain, NAME, utilsb,
                                weights, reservationBid2);

        }

        @Override
        public List<List<LinearAdditiveUtilitySpace>> getGeneralTestData() {
                return Arrays.asList(Arrays.asList(utilspace1, utilspace1a),
                                Arrays.asList(utilspace2a), Arrays.asList(utilspace2b),
                                Arrays.asList(utilspace3));
        }

        @Override
        public List<String> getGeneralTestStrings() {
                return Arrays.asList(
                                "LinearAdditive\\[\\{issue2=DiscreteValueSetUtilities\\{\"issue2value2\"=0.8, \"issue2value1\"=0.6\\}, issue1=DiscreteValueSetUtilities\\{\"issue1value1\"=0.3, \"issue1value2\"=0.2\\}\\},\\{issue2=0.6, issue1=0.4\\},Bid\\{issue2=\"issue2value1\", issue1=\"issue1value2\"\\}\\]",
                                "LinearAdditive\\[\\{issue2=DiscreteValueSetUtilities\\{\"issue2value2\"=0.8, \"issue2value1\"=0.6\\}, issue1=DiscreteValueSetUtilities\\{\"issue1value1\"=0.3, \"issue1value2\"=0.2\\}\\},\\{issue2=0.7, issue1=0.3\\},Bid\\{issue2=\"issue2value1\", issue1=\"issue1value2\"\\}\\]",
                                "LinearAdditive\\[\\{issue2=DiscreteValueSetUtilities\\{\"issue2value2\"=0.2, \"issue2value1\"=0.3\\}, issue1=DiscreteValueSetUtilities\\{\"issue1value1\"=0.6, \"issue1value2\"=0.8\\}\\},\\{issue2=0.6, issue1=0.4\\},Bid\\{issue2=\"issue2value1\", issue1=\"issue1value2\"\\}\\]",
                                "LinearAdditive\\[\\{issue2=DiscreteValueSetUtilities\\{\"issue2value2\"=0.2, \"issue2value1\"=0.3\\}, issue1=DiscreteValueSetUtilities\\{\"issue1value1\"=0.6, \"issue1value2\"=0.8\\}\\},\\{issue2=0.6, issue1=0.4\\},Bid\\{issue2=\"issue2value1\", issue1=\"issue1value1\"\\}\\]");
        }

        @Test(expected = NullPointerException.class)
        public void constructorNullIssuesTest() {
                new LinearAdditiveUtilitySpace(domain, NAME, null, null,
                                reservationBid);
        }

        @Test(expected = NullPointerException.class)
        public void constructorNullDomainTest() {
                new LinearAdditiveUtilitySpace(null, NAME, utils, weights,
                                reservationBid);
        }

        /**
         * Empty profile is not allowed since the weights then don't sum up to 1
         */
        @Test(expected = IllegalArgumentException.class)
        public void constructorEmptyTest() {
                new LinearAdditiveUtilitySpace(domain, NAME, new HashMap<>(), weights,
                                reservationBid);
        }

        @Test
        public void constructorOneIssueTest() {
                Map<String, ValueSetUtilities> utilset = new HashMap<>();
                Map<String, BigDecimal> weightset = new HashMap<>();
                utilset.put(ISS1, value1Utils);
                weightset.put(ISS1, BigDecimal.ONE);
                new LinearAdditiveUtilitySpace(smalldomain, NAME, utilset, weightset,
                                null);
        }

        /**
         * Empty profile is not allowed since the weights then don't sum up to 1
         */
        @Test(expected = IllegalArgumentException.class)
        public void constructoroneIssueTestWrongWeight() {
                Map<String, ValueSetUtilities> utilset = new HashMap<>();
                Map<String, BigDecimal> weightset = new HashMap<>();
                utilset.put(ISS1, value1Utils);
                weightset.put(ISS1, WEIGHT1);
                new LinearAdditiveUtilitySpace(smalldomain, NAME, utilset, weightset,
                                reservationBid);
        }

        /**
         * Try creating a domain and check isFitting
         */
        @Test
        public void checkCoversDomain() {
                Map<String, ValueSetUtilities> utilset = new HashMap<>();
                Map<String, BigDecimal> weightset = new HashMap<>();

                utilset.put(ISS1, value1Utils);
                weightset.put(ISS1, BigDecimal.ONE);
                LinearAdditiveUtilitySpace space = new LinearAdditiveUtilitySpace(
                                smalldomain, NAME, utilset, weightset, null);
        }

        /**
         * Try creating a domain and check isFitting but there is more issues in our
         * map than in the actual domain
         */
        @Test(expected = IllegalArgumentException.class)
        public void checkCoversWrongDomain() {
                Map<String, ValueSetUtilities> utilset = new HashMap<>();
                Map<String, BigDecimal> weightset = new HashMap<>();

                utilset.put(ISS1, value1Utils);
                weightset.put(ISS1, BigDecimal.ONE);
                LinearAdditiveUtilitySpace space = new LinearAdditiveUtilitySpace(
                                domain, NAME, utilset, weightset, reservationBid);
        }

        /**
         * Empty profile is not allowed since the weights then don't sum up to 1
         */
        @Test
        public void utilityTest() {
                LinearAdditiveUtilitySpace space = new LinearAdditiveUtilitySpace(
                                domain, NAME, utils, weights, reservationBid);

                Bid bid = mock(Bid.class);
                HashSet<String> issues = new HashSet<String>();
                issues.add(ISS1);
                when(bid.getIssues()).thenReturn(issues);
                when(bid.getValue(ISS1)).thenReturn(i1v1);
                assertEquals(0,
                                WEIGHT1.multiply(I1V1UTIL).compareTo(space.getUtility(bid)));
        }

        @Test
        public void preferredTest() {
                Map<String, Value> issuevalues = new HashMap<>();
                issuevalues.put(ISS1, i1v1);
                issuevalues.put(ISS2, i2v2);
                Bid bid1 = new Bid(issuevalues);
                Map<String, Value> issuevalues1 = new HashMap<>();
                issuevalues1.put(ISS1, i1v2);
                issuevalues1.put(ISS2, i2v1);
                Bid bid2 = new Bid(issuevalues1);
                assertTrue(utilspace1.isPreferredOrEqual(bid1, bid2));
                assertTrue(utilspace1.isPreferredOrEqual(bid1, bid1));
                assertTrue(utilspace1.isPreferredOrEqual(bid2, bid2));
                assertFalse(utilspace1.isPreferredOrEqual(bid2, bid1));
                assertFalse(utilspace1
                                .isPreferredOrEqual(new Bid(Collections.emptyMap()), bid1));
        }

        @Test
        public void partialBidUtilityTest() {
                LinearAdditiveUtilitySpace space = new LinearAdditiveUtilitySpace(
                                domain, NAME, utils, weights, reservationBid);
                Map<String, Value> issuevalues = new HashMap<>();
                issuevalues.put(ISS1, i1v1);
                Bid bid = new Bid(issuevalues);
                assertEquals(0,
                                WEIGHT1.multiply(I1V1UTIL).compareTo(space.getUtility(bid)));
        }

        @Test
        public void loadFullWithJson() throws IOException {
                String profile = new String(
                                Files.readAllBytes(Paths.get("src/test/resources/party1.json")),
                                StandardCharsets.UTF_8);
                UtilitySpace space = jackson.readValue(profile, UtilitySpace.class);

        }

        @Test
        public void loadFullWithJsonNumber() throws IOException {
                String profile = new String(
                                Files.readAllBytes(
                                                Paths.get("src/test/resources/japantrip1.json")),
                                StandardCharsets.UTF_8);
                UtilitySpace space = jackson.readValue(profile, UtilitySpace.class);

        }

        @Test(expected = IllegalArgumentException.class)
        public void testResBidWithNonsenseIssue() {
                Bid resBid = new Bid("nonsense", i1v1);
                new LinearAdditiveUtilitySpace(domain, NAME, utils, weights, resBid);
        }

        @Test(expected = IllegalArgumentException.class)
        public void testResBidWithWrongValueType() {
                Bid resBid = new Bid(ISS1, new NumberValue(BigDecimal.ZERO));
                new LinearAdditiveUtilitySpace(domain, NAME, utils, weights, resBid);
        }

        @Test(expected = IllegalArgumentException.class)
        public void testResBidWithNonsenseValue() {
                Bid resBid = new Bid(ISS1, new DiscreteValue("nonsense"));
                new LinearAdditiveUtilitySpace(domain, NAME, utils, weights, resBid);
        }

}