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

package geniusweb.bidspace.pareto;

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

import java.math.BigDecimal;
import java.util.ArrayList;
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 java.util.Set;

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

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;
import geniusweb.profile.Profile;

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 ValueSet values1;
        private static ValueSet values2;
        private static final BigDecimal TWO = new BigDecimal("2");
        private static final BigDecimal THREE = new BigDecimal("3");

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

        private PartialOrdering profile1, profile2, profile3;
        private GenericPareto pareto;

        @Before
        public void before() {
                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);

                profile1 = mock(PartialOrdering.class);
                profile2 = mock(PartialOrdering.class);
                profile3 = mock(PartialOrdering.class);
                when(profile1.getDomain()).thenReturn(domain);
                when(profile2.getDomain()).thenReturn(domain);
                when(profile3.getDomain()).thenReturn(domain);

                pareto = new GenericPareto(Arrays.asList(profile1, profile2));

        }

        @Test
        public void genericParetoTest() {

                // 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() {

                // 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);

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

        @Test
        public void genericParetoTest2() {

                // 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);

                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() {
                // 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);

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

        @Test
        public void genericParetoTest4() {

                // 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);

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

        @Test(expected = IllegalArgumentException.class)
        public void testNullNotOk() {
                new GenericPareto(Arrays.asList(profile1, null, profile1));
        }

        @Test
        public void testImmutable() {
                List<PartialOrdering> list = new ArrayList<>(
                                Arrays.asList(profile1, profile2));
                GenericPareto pareto = new GenericPareto(list);
                // if we modify the list, the pareto should not change
                list.add(profile3);
                assertEquals(2, pareto.getProfiles().size());
        }

        @Test(expected = UnsupportedOperationException.class)
        public void testGetParetoAndAdd() {
                List<Profile> list = pareto.getProfiles();
                list.add(profile3);

        }

        @Test(expected = UnsupportedOperationException.class)
        public void testGetPointsAndAdd() {
                Set<Bid> list = pareto.getPoints();
                list.add(bid1);
        }

}