source: anac2020/ShineAgent/src/test/java/shineagent/SimpleLinearOrderingTest.java@ 34

package shineagent;

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

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

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

import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Domain;
import geniusweb.profile.DefaultPartialOrdering;
import shineagent.SimpleLinearOrdering;

public class SimpleLinearOrderingTest {
        private DefaultPartialOrdering realprofile = mock(
                        DefaultPartialOrdering.class);;
        private Domain domain = mock(Domain.class);
        private SimpleLinearOrdering estprofile;
        private Bid bid1 = makeBid(1);
        private Bid bid2 = makeBid(2);
        private Bid bid3 = makeBid(3);
        private Bid bid4 = makeBid(4);
        private final List<Bid> emptyList = Collections.emptyList();

        @Before
        public void before() {
                when(realprofile.getDomain()).thenReturn(domain);
                estprofile = new SimpleLinearOrdering(realprofile);
                when(bid1.toString()).thenReturn("bid1");

        }

        private static Bid makeBid(int n) {
                Bid mockbid = mock(Bid.class);
                when(mockbid.toString()).thenReturn("bid " + n);
                return mockbid;
        }

        @Test
        public void testSmoke() {
        }

        @Test
        public void testInitialBids() {
                assertTrue(estprofile.getBids().isEmpty());
        }

        @Test
        public void largerInitialListTest() {
                when(realprofile.getBids()).thenReturn(Arrays.asList(bid1, bid2, bid3));
                // idea is that 3 > 2 > 1
                when(realprofile.isPreferredOrEqual(bid2, bid1)).thenReturn(true);
                when(realprofile.isPreferredOrEqual(bid1, bid2)).thenReturn(false);
                when(realprofile.isPreferredOrEqual(bid3, bid2)).thenReturn(true);
                when(realprofile.isPreferredOrEqual(bid2, bid3)).thenReturn(false);
                when(realprofile.isPreferredOrEqual(bid3, bid1)).thenReturn(true);
                when(realprofile.isPreferredOrEqual(bid1, bid3)).thenReturn(false);
                SimpleLinearOrdering testprofile = new SimpleLinearOrdering(
                                realprofile);
                assertEquals(Arrays.asList(bid1, bid2, bid3), testprofile.getBids());
        }

        @Test
        public void testAddFirstBid() {
                SimpleLinearOrdering prof1 = estprofile.with(bid1,
                                Collections.emptyList());

                assertEquals(1, prof1.getBids().size());
        }

        @Test
        public void testAddTwoBidsSecondIsWorse() {
                SimpleLinearOrdering prof1 = estprofile.with(bid1, emptyList);
                // new bid is worse as bid1, so list of worse bids is empty
                SimpleLinearOrdering prof2 = prof1.with(bid2, emptyList);

                assertEquals(Arrays.asList(bid2, bid1), prof2.getBids());
        }

        @Test
        public void testAddTwoBidsSecondIsBetter() {
                SimpleLinearOrdering prof1 = estprofile.with(bid1, emptyList);
                SimpleLinearOrdering prof2 = prof1.with(bid2, Arrays.asList(bid1));

                assertEquals(Arrays.asList(bid1, bid2), prof2.getBids());
        }

        @Test
        public void testAddThreeBidsThirdIsMiddle() {
                SimpleLinearOrdering prof1 = new SimpleLinearOrdering(domain,
                                Arrays.asList(bid1, bid2));
                SimpleLinearOrdering prof2 = prof1.with(bid3, Arrays.asList(bid1));

                assertEquals(Arrays.asList(bid1, bid3, bid2), prof2.getBids());
        }

        @Test
        public void getUtilityTest3Bids() {
                SimpleLinearOrdering prof1 = new SimpleLinearOrdering(domain,
                                Arrays.asList(bid1, bid3, bid2));

                assertEquals(new BigDecimal("0.50000000"), prof1.getUtility(bid3));
        }

        @Test
        public void getUtilityTest4Bids() {
                // with 4 bids, we get utility 1/3 which causes deximal expansiion issue
                SimpleLinearOrdering prof1 = new SimpleLinearOrdering(domain,
                                Arrays.asList(bid1, bid2, bid3, bid4));

                assertEquals(new BigDecimal("0.33333333"), prof1.getUtility(bid2));
        }

}