source: voting/src/test/java/geniusweb/voting/evaluatorwithvalue/LargestAgreementWithValueTest.java@ 52

package geniusweb.voting.evaluatorwithvalue;

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

import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
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.VoteWithValue;
import geniusweb.actions.VotesWithValue;
import geniusweb.inform.Agreements;
import geniusweb.issuevalue.Bid;
import geniusweb.voting.CollectedVotesWithValue;
import geniusweb.voting.VotingEvaluatorWithValue;
import tudelft.utilities.junit.GeneralTests;

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

        private LargestAgreementWithValue lal1 = new LargestAgreementWithValue();
        private LargestAgreementWithValue lal1a = new LargestAgreementWithValue();
        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 VotesWithValue votes1 = mock(VotesWithValue.class);
        private LargestAgreementWithValue lal2 = new LargestAgreementWithValue(
                        new CollectedVotesWithValue(
                                        Collections.singletonMap(party1, votes1),
                                        Collections.singletonMap(party1, 1)));

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

        @Override
        public List<List<LargestAgreementWithValue>> 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 {
                VotingEvaluatorWithValue eval = jackson.readValue(lalstring,
                                VotingEvaluatorWithValue.class);
                // it should deserialize as the empty lal1 because we ignore the fields.
                assertEquals(lal1, eval);
        }

        @Test
        public void testCollectVotes() {
                Bid bid1 = mock(Bid.class);
                when(bid1.toString()).thenReturn("bid1");
                Bid bid2 = mock(Bid.class);
                when(bid2.toString()).thenReturn("bid2");

                VotesWithValue votes1 = new VotesWithValue(party1,
                                new HashSet<>(Arrays.asList(
                                                new VoteWithValue(party1, bid1, 2, 99, 40),
                                                new VoteWithValue(party1, bid2, 2, 99, 60))));
                VotesWithValue votes2 = new VotesWithValue(party2, new HashSet<>(
                                Arrays.asList(new VoteWithValue(party2, bid1, 2, 99, 100))));
                VotesWithValue votes3 = new VotesWithValue(party3, new HashSet<>(
                                Arrays.asList(new VoteWithValue(party3, bid1, 2, 99, 100))));
                VotesWithValue votes4 = new VotesWithValue(party4, new HashSet<>(
                                Arrays.asList(new VoteWithValue(party4, bid1, 2, 99, 100))));
                HashMap<PartyId, VotesWithValue> votesmap = new HashMap<>();
                votesmap.put(party1, votes1);
                votesmap.put(party2, votes2);
                votesmap.put(party3, votes3);
                votesmap.put(party4, votes4);
                HashMap<PartyId, Integer> powermap = new HashMap<>();
                powermap.put(party1, 1);
                powermap.put(party2, 1);
                powermap.put(party3, 1);
                powermap.put(party4, 4);

                CollectedVotesWithValue votes = new CollectedVotesWithValue(votesmap,
                                powermap);

                LargestAgreementWithValue la = new LargestAgreementWithValue(votes);
                Agreements agreement = la.getAgreements();
                assertEquals(
                                new HashSet<PartyId>(
                                                Arrays.asList(party1, party2, party3, party4)),
                                agreement.getMap().keySet());
        }

        @Test
        public void testEmptyCollectVotes() {

                CollectedVotesWithValue votes = new CollectedVotesWithValue(
                                Collections.emptyMap(), Collections.emptyMap());

                LargestAgreementWithValue la = new LargestAgreementWithValue(votes);
                Agreements agreement = la.getAgreements();
        }
}