source: bidspace/src/test/java/geniusweb/bidspace/pareto/GenericParetoTest.java@ 43

package geniusweb.bidspace.pareto;

import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
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.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.junit.Test;

import geniusweb.bidspace.pareto.GenericPareto;
import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.DiscreteValue;
import geniusweb.issuevalue.DiscreteValueSet;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.NumberValue;
import geniusweb.issuevalue.NumberValueSet;
import geniusweb.issuevalue.Value;
import geniusweb.issuevalue.ValueSet;
import geniusweb.profile.PartialOrdering;

public class GenericParetoTest {
        private static final DiscreteValue I1V2 = new DiscreteValue("i1v2");
        private static final DiscreteValue I1V1 = new DiscreteValue("i1v1");
        private static final NumberValue I2V1 = new NumberValue("2.00");
        private static final NumberValue I2V2 = new NumberValue("2.45");
        private static final NumberValue I2V3 = new NumberValue("2.90");
        private static final String DOMAINNAME = "testdomain";
        private static final String ISSUE1 = "issue1";
        private static final String ISSUE2 = "issue2";
        private static final Map<String, ValueSet> issues = new HashMap<>();

        private static final ValueSet values1;
        private static final ValueSet values2;
        private static final BigDecimal TWO = new BigDecimal("2");
        private static final BigDecimal THREE = new BigDecimal("3");

        private static final Domain domain;
        private static Bid bid1, bid2, bid3;

        static {
                Collection<DiscreteValue> discretevalues1 = new LinkedList<>();
                discretevalues1.add(I1V1);
                discretevalues1.add(I1V2);
                values1 = new DiscreteValueSet(discretevalues1);
                issues.put(ISSUE1, values1);

                values2 = new NumberValueSet(TWO, THREE, new BigDecimal("0.45"));
                issues.put(ISSUE2, values2);

                domain = new Domain(DOMAINNAME, issues);

                Map<String, Value> issuevalues = new HashMap<>();
                issuevalues.put(ISSUE1, I1V1);
                issuevalues.put(ISSUE2, I2V1);
                bid1 = new Bid(issuevalues);
                issuevalues.put(ISSUE1, I1V1);
                issuevalues.put(ISSUE2, I2V2);
                bid2 = new Bid(issuevalues);
                issuevalues.put(ISSUE1, I1V2);
                issuevalues.put(ISSUE2, I2V1);
                bid3 = new Bid(issuevalues);

        }

        @Test
        public void genericParetoTest() {
                PartialOrdering profile1 = mock(PartialOrdering.class);
                PartialOrdering profile2 = mock(PartialOrdering.class);

                when(profile1.getDomain()).thenReturn(domain);
                when(profile2.getDomain()).thenReturn(domain);

                // fefault: there is no preference at all, all isPreferredOrEqual
                // returns false and we can't remove pareto points.

                List<PartialOrdering> profiles = Arrays.asList(profile1, profile2);
                GenericPareto pareto = new GenericPareto(profiles);

                Collection<Bid> points = pareto.getPoints();
                assertEquals(6, points.size());
        }

        @Test
        public void genericParetoTest1() {
                PartialOrdering profile1 = mock(PartialOrdering.class);
                PartialOrdering profile2 = mock(PartialOrdering.class);

                when(profile1.getDomain()).thenReturn(domain);
                when(profile2.getDomain()).thenReturn(domain);

                // both prefer bid1 over any other bid.
                when(profile1.isPreferredOrEqual(eq(bid1), any(Bid.class)))
                                .thenReturn(true);
                when(profile2.isPreferredOrEqual(eq(bid1), any(Bid.class)))
                                .thenReturn(true);

                List<PartialOrdering> profiles = Arrays.asList(profile1, profile2);
                GenericPareto pareto = new GenericPareto(profiles);

                Collection<Bid> points = pareto.getPoints();
                assertEquals(1, points.size());
                assertEquals(bid1, points.iterator().next());
        }

        @Test
        public void genericParetoTest2() {
                PartialOrdering profile1 = mock(PartialOrdering.class);
                PartialOrdering profile2 = mock(PartialOrdering.class);

                when(profile1.getDomain()).thenReturn(domain);
                when(profile2.getDomain()).thenReturn(domain);

                // both prefer bid2 over any other bid.
                when(profile1.isPreferredOrEqual(eq(bid2), any(Bid.class)))
                                .thenReturn(true);
                when(profile2.isPreferredOrEqual(eq(bid2), any(Bid.class)))
                                .thenReturn(true);
                List<PartialOrdering> profiles = Arrays.asList(profile1, profile2);
                GenericPareto pareto = new GenericPareto(profiles);

                Collection<Bid> points = pareto.getPoints();
                // since both prefer bid2, bid is pareto point.
                assertEquals(1, points.size());
                assertEquals(bid2, points.iterator().next());
        }

        @Test
        public void genericParetoTest3() {
                PartialOrdering profile1 = mock(PartialOrdering.class);
                PartialOrdering profile2 = mock(PartialOrdering.class);

                when(profile1.getDomain()).thenReturn(domain);
                when(profile2.getDomain()).thenReturn(domain);

                // profile1 prefers bid1, profile2 prefers bid2.
                // now neither bid1 nor bid2 are dominating each other
                // and nor does bid1 or bid2 dominate anything else.
                when(profile1.isPreferredOrEqual(eq(bid1), any(Bid.class)))
                                .thenReturn(true);
                when(profile2.isPreferredOrEqual(eq(bid2), any(Bid.class)))
                                .thenReturn(true);
                List<PartialOrdering> profiles = Arrays.asList(profile1, profile2);
                GenericPareto pareto = new GenericPareto(profiles);

                Collection<Bid> points = pareto.getPoints();
                // since both prefer bid2, bid is pareto point.
                assertEquals(6, points.size());
        }

        @Test
        public void genericParetoTest4() {
                PartialOrdering profile1 = mock(PartialOrdering.class);
                PartialOrdering profile2 = mock(PartialOrdering.class);

                when(profile1.getDomain()).thenReturn(domain);
                when(profile2.getDomain()).thenReturn(domain);

                // profile1 prefers bid1, profile2 prefers bid2.
                // but they both hate bid3.
                when(profile1.isPreferredOrEqual(eq(bid1), any(Bid.class)))
                                .thenReturn(true);
                when(profile1.isPreferredOrEqual(any(Bid.class), eq(bid3)))
                                .thenReturn(true);
                when(profile2.isPreferredOrEqual(any(Bid.class), eq(bid3)))
                                .thenReturn(true);
                when(profile2.isPreferredOrEqual(eq(bid2), any(Bid.class)))
                                .thenReturn(true);
                List<PartialOrdering> profiles = Arrays.asList(profile1, profile2);
                GenericPareto pareto = new GenericPareto(profiles);

                Collection<Bid> points = pareto.getPoints();
                // both hate bid3 but don't agree on bid1/2. bid3 is ruled out.
                assertEquals(5, points.size());
        }

}