source: bidspace/src/test/java/geniusweb/bidspace/pareto/ParetoPointTest.java@ 30

package geniusweb.bidspace.pareto;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
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.HashSet;

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

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

public class ParetoPointTest {
        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 final Bid bid11 = mock(Bid.class), bid12 = mock(Bid.class),
                        bid21 = mock(Bid.class), bid22 = mock(Bid.class);
        private ParetoPoint point11, point12, point21, point22;

        @Before
        public void before() {
                when(space1.getUtility(eq(bid11))).thenReturn(D0_1);
                when(space2.getUtility(eq(bid11))).thenReturn(D0_1);

                when(space1.getUtility(eq(bid12))).thenReturn(D0_1);
                when(space2.getUtility(eq(bid12))).thenReturn(D0_2);

                when(space1.getUtility(eq(bid21))).thenReturn(D0_2);
                when(space2.getUtility(eq(bid21))).thenReturn(D0_1);

                when(space1.getUtility(eq(bid22))).thenReturn(D0_2);
                when(space2.getUtility(eq(bid22))).thenReturn(D0_2);

                point11 = new ParetoPoint(bid11, Arrays.asList(space1, space2));
                point12 = new ParetoPoint(bid12, Arrays.asList(space1, space2));
                point21 = new ParetoPoint(bid21, Arrays.asList(space1, space2));
                point22 = new ParetoPoint(bid22, Arrays.asList(space1, space2));
        }

        @Test
        public void constructorTest() {
                assertEquals(bid11, point11.getBid());
                assertEquals(bid21, point21.getBid());

                assertEquals(Arrays.asList(D0_1, D0_1), point11.getUtilities());
                assertEquals(Arrays.asList(D0_2, D0_1), point21.getUtilities());
        }

        @Test
        public void dominationTest() {
                assertTrue(point11.isDominatedBy(point11));
                assertTrue(point11.isDominatedBy(point12));
                assertTrue(point11.isDominatedBy(point21));
                assertTrue(point11.isDominatedBy(point22));

                assertFalse(point12.isDominatedBy(point11));
                assertFalse(point12.isDominatedBy(point21));
                assertTrue(point12.isDominatedBy(point12));
                assertTrue(point12.isDominatedBy(point22));

                assertFalse(point21.isDominatedBy(point11));
                assertFalse(point21.isDominatedBy(point12));
                assertTrue(point21.isDominatedBy(point21));
                assertTrue(point21.isDominatedBy(point22));

                assertFalse(point22.isDominatedBy(point11));
                assertFalse(point22.isDominatedBy(point12));
                assertFalse(point22.isDominatedBy(point21));
                assertTrue(point22.isDominatedBy(point22));
        }

        @Test
        public void mergeTest() {
                // partial bid 020_010 has value 0.2 for issue 2 in space1 and 0.1 for
                // issue 2 in space2.
                Bid partialbid020_010 = mock(Bid.class),
                                partialbid102_301 = mock(Bid.class);
                // merged this should be a bid 122_311 so it has utilities
                // 1+2+2=0.5 in space1 and 3+1+1=0.5 in space2

                when(partialbid020_010.getIssues())
                                .thenReturn(new HashSet<String>(Arrays.asList("issue2")));
                when(partialbid102_301.getIssues()).thenReturn(
                                new HashSet<String>(Arrays.asList("issue1", "issue3")));

                Value value1 = mock(Value.class), value2 = mock(Value.class),
                                value3 = mock(Value.class);
                when(partialbid020_010.getValue(eq("issue2"))).thenReturn(value2);
                when(partialbid102_301.getValue(eq("issue1"))).thenReturn(value1);
                when(partialbid102_301.getValue(eq("issue3"))).thenReturn(value3);

                when(space1.getUtility(eq(partialbid020_010))).thenReturn(D0_2);
                when(space1.getUtility(eq(partialbid102_301))).thenReturn(D0_3);
                when(space2.getUtility(eq(partialbid020_010))).thenReturn(D0_1);
                when(space2.getUtility(eq(partialbid102_301))).thenReturn(D0_4);

                ParetoPoint p1 = new ParetoPoint(partialbid020_010,
                                Arrays.asList(space1, space2));
                ParetoPoint p2 = new ParetoPoint(partialbid102_301,
                                Arrays.asList(space1, space2));

                ParetoPoint p = p1.merge(p2);
                Bid bid = p.getBid();
                assertEquals(
                                new HashSet<String>(
                                                Arrays.asList("issue1", "issue2", "issue3")),
                                bid.getIssues());
                assertEquals(value1, bid.getValue("issue1"));
                assertEquals(value2, bid.getValue("issue2"));
                assertEquals(value3, bid.getValue("issue3"));
                assertEquals(D0_5, p.getUtilities().get(0));
                assertEquals(D0_5, p.getUtilities().get(1));
        }

}