source: protocol/src/test/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsStateTest.java@ 52

package geniusweb.protocol.tournament.allpermutations;

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

import java.io.File;
import java.io.IOException;
import java.math.BigInteger;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

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

import com.fasterxml.jackson.databind.ObjectMapper;

import geniusweb.actions.PartyId;
import geniusweb.protocol.NegoState;
import geniusweb.protocol.session.SessionResult;
import geniusweb.protocol.session.SessionSettings;
import geniusweb.references.PartyWithProfile;
import tudelft.utilities.immutablelist.ImmutableList;

public class AllPermutationsStateTest {
        private final static ObjectMapper jackson = new ObjectMapper();
        private final AllPermutationsSettings toursettings = mock(
                        AllPermutationsSettings.class);;
        @SuppressWarnings("unchecked")
        private final List<SessionResult> results = mock(List.class);
        @SuppressWarnings("unchecked")
        private final ImmutableList<SessionSettings> settings = mock(
                        ImmutableList.class);
        private final AllPermutationsState state = new AllPermutationsState(
                        toursettings, results);
        private final SessionSettings session7settings = mock(
                        SessionSettings.class);
        private final long NOW = 1000;
        private PartyWithProfile pp1 = mock(PartyWithProfile.class);
        private PartyWithProfile pp2 = mock(PartyWithProfile.class);

        @Before
        public void before() {
                when(toursettings.permutations()).thenReturn(settings);
        }

        @SuppressWarnings("unchecked")
        private final List<PartyWithProfile> participants = Arrays.asList(pp1, pp2);

        @Test
        public void getResultsTest() {
                assertEquals(results, state.getResults());
        }

        @Test
        public void isFinalTestFalse() {
                when(settings.size()).thenReturn(BigInteger.TEN);
                when(results.size()).thenReturn(11);
                assertFalse(state.isFinal(NOW));
        }

        @Test
        public void isFinalTestTrue() {
                when(settings.size()).thenReturn(BigInteger.TEN);
                when(results.size()).thenReturn(10);
                assertTrue(state.isFinal(NOW));
        }

        @Test
        public void getNextSetting() {
                prepareNextSettings();
                assertEquals(session7settings, state.getNextSettings());
        }

        private void prepareNextSettings() {
                when(results.size()).thenReturn(7); // result 0..6
                when(settings.size()).thenReturn(BigInteger.TEN);
                // when(session7settings.getTeams()).thenReturn(participants);
                when(session7settings.getAllParties()).thenReturn(participants);
                when(settings.get(BigInteger.valueOf(7))).thenReturn(session7settings);

        }

        @Test
        public void withTest() {
                prepareNextSettings();
                ArrayList<SessionResult> results1 = new ArrayList<>();
                for (int n = 0; n < 7; n++) {
                        results1.add(mock(SessionResult.class));
                }
                // use state with "real" results... to allow array copy in with
                AllPermutationsState state = new AllPermutationsState(toursettings,
                                results1);

                when(settings.size()).thenReturn(BigInteger.TEN);
                when(settings.get(BigInteger.valueOf(7))).thenReturn(session7settings);

                SessionResult result = mock(SessionResult.class);

                Map<PartyId, PartyWithProfile> participants3 = mock(Map.class);
                when(participants3.values()).thenReturn(participants);
                when(result.getParticipants()).thenReturn(participants3);
                AllPermutationsState state1 = state.with(Arrays.asList(result));

                assertEquals(8, state1.getResults().size());
                assertEquals(toursettings, state1.getSettings());

        }

        @Test
        public void testDeserialize() throws IOException {
                NegoState state = jackson.readValue(
                                new File("src/test/resources/APP1646925947841.json"),
                                NegoState.class);
                assertTrue(state instanceof AllPermutationsState);
                AllPermutationsState negostate = (AllPermutationsState) state;

                System.out.println(negostate);
                // all sessions should be done so time irrelevant
                assertTrue(negostate.isFinal(0));
                assertEquals(1, negostate.getSettings().getNrTournaments());
        }

        @Test
        public void testSerialize() throws URISyntaxException, IOException {
                NegoState obj = jackson.readValue(
                                new File("src/test/resources/APP1646925947841.json"),
                                NegoState.class);
                String string = jackson.writeValueAsString(obj);
                // just smoke test, FIXME really check the output.
        }
}