source: bidspace/src/test/java/geniusweb/bidspace/pareto/PartialParetoTest.java@ 52

package geniusweb.bidspace.pareto;

import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

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

import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.Value;
import geniusweb.issuevalue.ValueSet;
import geniusweb.profile.utilityspace.LinearAdditive;

public class PartialParetoTest {
        private static final BigDecimal D0_0 = BigDecimal.ZERO;
        private static final BigDecimal D0_2 = BigDecimal.valueOf(0.2);
        private static final BigDecimal D0_1 = BigDecimal.valueOf(0.1);
        private static final BigDecimal D0_3 = BigDecimal.valueOf(0.3);
        private static final BigDecimal D0_4 = BigDecimal.valueOf(0.4);
        private static final BigDecimal D0_5 = BigDecimal.valueOf(0.5);

        private final LinearAdditive space1 = mock(LinearAdditive.class),
                        space2 = mock(LinearAdditive.class);

        private Domain domain = mock(Domain.class);
        private Set<String> issues = new HashSet<String>(
                        Arrays.asList("issue1", "issue2"));
        private Value value1a = mock(Value.class), value1b = mock(Value.class);
        private Value value2a = mock(Value.class), value2b = mock(Value.class);
        private ValueSet issue1valueset = mock(ValueSet.class),
                        issue2valueset = mock(ValueSet.class);

        @Before
        public void before() {
                when(value1a.toString()).thenReturn("1A");
                when(value1b.toString()).thenReturn("1B");
                when(value2a.toString()).thenReturn("2A");
                when(value2b.toString()).thenReturn("2B");

                Map<String, Value> map = new HashMap<>();
                map.put("issue1", value1a);
                Bid bid10 = new Bid(map);
                map.put("issue1", value1b);
                Bid bid20 = new Bid(map);

                map = new HashMap<>();
                map.put("issue2", value2a);
                Bid bid01 = new Bid(map);
                map.put("issue2", value2b);
                Bid bid02 = new Bid(map);

                when(space1.getUtility(eq(bid10))).thenReturn(D0_1);
                when(space2.getUtility(eq(bid10))).thenReturn(D0_0);

                when(space1.getUtility(eq(bid20))).thenReturn(D0_2);
                when(space2.getUtility(eq(bid20))).thenReturn(D0_0);

                when(space1.getUtility(eq(bid01))).thenReturn(D0_0);
                when(space2.getUtility(eq(bid01))).thenReturn(D0_1);

                when(space1.getUtility(eq(bid02))).thenReturn(D0_0);
                when(space2.getUtility(eq(bid02))).thenReturn(D0_2);

                when(space1.getDomain()).thenReturn(domain);
                when(domain.getIssues()).thenReturn(issues);
                when(issue1valueset.iterator())
                                .thenReturn(Arrays.asList(value1a, value1b).iterator());
                when(domain.getValues("issue1")).thenReturn(issue1valueset);
                // by putting the best value first in the list now,
                // we may trigger a different evaluation path in the PartialPareto
                // algorithm, improving coverage
                when(issue2valueset.iterator())
                                .thenReturn(Arrays.asList(value2b, value2a).iterator());

                when(domain.getValues("issue2")).thenReturn(issue2valueset);
        }

        @Test
        public void OneIssueTest() {
                PartialPareto pp = PartialPareto.create(Arrays.asList(space1, space2),
                                Arrays.asList("issue1"));
                // bid22 is best for both. Check that's the only remaining point
                assertEquals(1, pp.getPoints().size());
                Map<String, Value> map = new HashMap<>();
                map.put("issue1", value1b);
                // there is no value for issue2 because we asked to exclude it from the
                // pareto.
                assertEquals(new Bid(map), pp.getPoints().get(0).getBid());

        }

        @Test
        public void TwoIssuesTest() {
                PartialPareto pp = PartialPareto.create(Arrays.asList(space1, space2),
                                Arrays.asList("issue1", "issue2"));
                // bid22 is best for both. Check that's the only remaining point
                assertEquals(1, pp.getPoints().size());
                Map<String, Value> map = new HashMap<>();
                map.put("issue1", value1b);
                map.put("issue2", value2b);
                assertEquals(new Bid(map), pp.getPoints().get(0).getBid());

        }
}