source: voting/src/test/java/geniusweb/voting/votingevaluators/LargestAgreementTest.java@ 52

package geniusweb.voting.votingevaluators;

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

import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;

import org.junit.Test;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import geniusweb.actions.PartyId;
import geniusweb.actions.Vote;
import geniusweb.actions.Votes;
import geniusweb.inform.Agreements;
import geniusweb.issuevalue.Bid;
import geniusweb.voting.CollectedVotes;
import geniusweb.voting.VotingEvaluator;
import tudelft.utilities.junit.GeneralTests;

public class LargestAgreementTest extends GeneralTests<LargestAgreement> {
        private final ObjectMapper jackson = new ObjectMapper();

        private LargestAgreement lal1 = new LargestAgreement();
        private LargestAgreement lal1a = new LargestAgreement();
        private PartyId party1 = new PartyId("party1");
        private PartyId party2 = new PartyId("party2");
        private PartyId party3 = new PartyId("party3");
        private PartyId party4 = new PartyId("party4");
        private Votes votes1 = mock(Votes.class);
        private LargestAgreement lal2 = new LargestAgreement(
                        new CollectedVotes(Collections.singletonMap(party1, votes1),
                                        Collections.singletonMap(party1, 1)));

        private String lalstring = "{\"LargestAgreement\":{}}";

        @Override
        public List<List<LargestAgreement>> getGeneralTestData() {
                return Arrays.asList(Arrays.asList(lal1, lal1a), Arrays.asList(lal2));
        }

        @Override
        public List<String> getGeneralTestStrings() {
                return Arrays.asList("LargestAgreement", "LargestAgreement");
        }

        @Test
        public void serializeTest() throws JsonProcessingException {
                // we use lal2 to also check we don't serialize the contents
                System.out.println(jackson.writeValueAsString(lal2));
                assertEquals(lalstring, jackson.writeValueAsString(lal2));
        }

        @Test
        public void deserializeTest() throws IOException {
                VotingEvaluator eval = jackson.readValue(lalstring,
                                VotingEvaluator.class);
                // it should deserialize as the empty lal1 because we ignore the fields.
                assertEquals(lal1, eval);
        }

        @Test
        public void testCollectVotes() {
                // we set up a tricky situation where party4 has much more power
                // and therefore party 1+4 >> p1+2+3
                Bid bid1 = mock(Bid.class);
                Bid bid2 = mock(Bid.class);

                CollectedVotes votes = new CollectedVotes(Collections.emptyMap(),
                                Collections.emptyMap());
                votes = votes.with(new Votes(party1,
                                new HashSet<>(Arrays.asList(new Vote(party1, bid1, 1, 99),
                                                new Vote(party1, bid2, 1, 99)))),
                                1);
                votes = votes.with(
                                new Votes(party2,
                                                new HashSet<>(
                                                                Arrays.asList(new Vote(party2, bid1, 1, 99)))),
                                1);
                votes = votes.with(
                                new Votes(party3,
                                                new HashSet<>(
                                                                Arrays.asList(new Vote(party3, bid1, 1, 99)))),
                                1);
                votes = votes.with(
                                new Votes(party4,
                                                new HashSet<>(
                                                                Arrays.asList(new Vote(party4, bid2, 1, 99)))),
                                4);
                LargestAgreement la = new LargestAgreement(votes);
                Agreements agreement = la.collectVotes();
                assertEquals(new HashSet<PartyId>(Arrays.asList(party1, party4)),
                                agreement.getMap().keySet());
        }

}