source: protocol/src/test/java/geniusweb/protocol/tournament/allpermutationslearn/AllPermutationsLearnStateTest.java@ 52

package geniusweb.protocol.tournament.allpermutationslearn;

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.math.BigInteger;
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 geniusweb.actions.PartyId;
import geniusweb.protocol.session.SessionResult;
import geniusweb.protocol.session.SessionSettings;
import geniusweb.references.PartyWithProfile;
import tudelft.utilities.immutablelist.ImmutableList;

public class AllPermutationsLearnStateTest {

        private final AllPermutationsLearnSettings toursettings = mock(
                        AllPermutationsLearnSettings.class);;
        @SuppressWarnings("unchecked")
        private final List<SessionResult> results = mock(List.class);
        @SuppressWarnings("unchecked")
        private final ImmutableList<SessionSettings> sesettings = mock(
                        ImmutableList.class);
        private final AllPermutationsLearnState state = new AllPermutationsLearnState(
                        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);

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

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

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

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

        @Test
        public void isFinalTestTrue() {
                when(sesettings.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(sesettings.size()).thenReturn(BigInteger.TEN);
                // when(session7settings.getTeams()).thenReturn(participants);
                when(session7settings.getAllParties()).thenReturn(participants);
                when(sesettings.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
                AllPermutationsLearnState state0 = new AllPermutationsLearnState(
                                toursettings, results1);

                when(sesettings.size()).thenReturn(BigInteger.TEN);
                when(sesettings.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);
                AllPermutationsLearnState state1 = state0.with(Arrays.asList(result));

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

        }
}