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

package geniusweb.protocol.tournament.allpermutationslearn;

import static org.junit.Assert.assertEquals;

import java.io.IOException;
import java.math.BigInteger;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

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

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

import geniusweb.deadline.DeadlineTime;
import geniusweb.protocol.NegoSettings;
import geniusweb.protocol.session.SessionSettings;
import geniusweb.protocol.session.learn.LearnSettings;
import geniusweb.protocol.session.saop.SAOPSettings;
import geniusweb.protocol.tournament.ProfileList;
import geniusweb.protocol.tournament.Team;
import geniusweb.protocol.tournament.TournamentSettings;
import geniusweb.references.Parameters;
import geniusweb.references.PartyRef;
import geniusweb.references.PartyWithParameters;
import geniusweb.references.ProfileRef;
import tudelft.utilities.immutablelist.ImmutableList;
import tudelft.utilities.junit.GeneralTests;
import tudelft.utilities.logging.ReportToLogger;

public class AllPermutationsLearnSettingsTest
                extends GeneralTests<AllPermutationsLearnSettings> {

        private final ObjectMapper jackson = new ObjectMapper();

        private final String serialized = "{\"AllPermutationsLearnSettings\":{\"teams\":[{\"Team\":[{\"partyref\":\"party1\",\"parameters\":{\"persistentstate\":\"a48b8bc9-4275-4a4e-bee9-6c0a734dc99a\",\"negotiationdata\":[]}}]},{\"Team\":[{\"partyref\":\"party2\",\"parameters\":{\"persistentstate\":\"12b6af6c-b8a0-4731-8b37-0454cafeb7f4\",\"negotiationdata\":[]}}]}],\"profileslists\":[{\"ProfileList\":[\"profile1\"]},{\"ProfileList\":[\"profile2\"]},{\"ProfileList\":[\"profile3\"]}],\"reuseTeams\":false,\"teamsPerSession\":2,\"sessionsettings\":{\"SAOPSettings\":{\"participants\":[],\"deadline\":{\"DeadlineTime\":{\"durationms\":10000}}}},\"numberTournaments\":1,\"learnSettings\":{\"LearnSettings\":{\"participants\":[],\"deadline\":{\"DeadlineTime\":{\"durationms\":99000}}}}}}";
        private AllPermutationsLearnSettings settings, settings1a, settings2,
                        settings3, settings4, settings5;

        // use directly because there is some hard coding currently.
        private SAOPSettings saopsettings;

        private ProfileRef profile1, profile2, profile3;
        private ProfileList profiles1, profiles2, profiles3;
        private List<Team> parties, parties3;

        private LearnSettings learnsettings;

        private List<ProfileList> profiles;

        @Before
        public void before() throws URISyntaxException {

                PartyRef partyref1 = new PartyRef("party1");
                PartyRef partyref2 = new PartyRef("party2");
                PartyRef partyref3 = new PartyRef("party3");

                Parameters params1 = new Parameters()
                                .with("persistentstate", "a48b8bc9-4275-4a4e-bee9-6c0a734dc99a")
                                .with("negotiationdata", Collections.emptyList());
                Parameters params2 = new Parameters()
                                .with("persistentstate", "12b6af6c-b8a0-4731-8b37-0454cafeb7f4")
                                .with("negotiationdata", Collections.emptyList());
                Parameters params3 = new Parameters()
                                .with("persistentstate", "2b9488ed-c06b-4027-826b-4528254558f1")
                                .with("negotiationdata", Collections.emptyList());

                PartyWithParameters pwithp1 = new PartyWithParameters(partyref1,
                                params1);
                PartyWithParameters pwithp2 = new PartyWithParameters(partyref2,
                                params2);
                PartyWithParameters pwithp3 = new PartyWithParameters(partyref3,
                                params3);
                Team partywithparams1 = new Team(Arrays.asList(pwithp1));
                Team partywithparams2 = new Team(Arrays.asList(pwithp2));
                Team partywithparams3 = new Team(Arrays.asList(pwithp3));

                parties = Arrays.asList(partywithparams1, partywithparams2);
                parties3 = Arrays.asList(partywithparams1, partywithparams2,
                                partywithparams3);
                DeadlineTime deadline = new DeadlineTime(10000);

                saopsettings = new SAOPSettings(Collections.emptyList(), deadline);

                profile1 = new ProfileRef("profile1");
                profile2 = new ProfileRef("profile2");
                profile3 = new ProfileRef("profile3");
                profiles1 = new ProfileList(Arrays.asList(profile1));
                profiles2 = new ProfileList(Arrays.asList(profile2));
                profiles3 = new ProfileList(Arrays.asList(profile3));

                learnsettings = new LearnSettings(Collections.emptyList(),
                                new DeadlineTime(99000));

                profiles = Arrays.asList(profiles1, profiles2, profiles3);

                settings = new AllPermutationsLearnSettings(parties, profiles, false, 2,
                                saopsettings, 1, learnsettings);

                settings1a = new AllPermutationsLearnSettings(parties, profiles, false,
                                2, saopsettings, 1, learnsettings);

                settings2 = new AllPermutationsLearnSettings(
                                Arrays.asList(partywithparams1, partywithparams2,
                                                partywithparams3),
                                profiles, false, 2, saopsettings, 1, learnsettings);

                settings3 = new AllPermutationsLearnSettings(parties, profiles, true, 2,
                                saopsettings, 1, learnsettings);

                settings4 = new AllPermutationsLearnSettings(parties,
                                Arrays.asList(profiles1, profiles2, profiles3, profiles1),
                                false, 2, saopsettings, 1, learnsettings);

                settings5 = new AllPermutationsLearnSettings(parties, profiles, false,
                                2, saopsettings, 2, learnsettings);

        }

        @Override
        public List<List<AllPermutationsLearnSettings>> getGeneralTestData() {
                return Arrays.asList(Arrays.asList(settings, settings1a),
                                Arrays.asList(settings2), Arrays.asList(settings3),
                                Arrays.asList(settings4), Arrays.asList(settings5));
        }

        @Override
        public List<String> getGeneralTestStrings() {
                return Arrays.asList(
                                "AllPermutationsLearnSettings.*party1.*party2.*,false,.*profile1.*profile2.*profile3.*,2,SAOPSettings.*1.*",
                                "AllPermutationsLearnSettings.*party1.*party2.*party3.*,false,.*profile1.*profile2.*profile3.*,2,SAOPSettings.*1.*",
                                "AllPermutationsLearnSettings.*party1.*party2.*,true,.*profile1.*profile2.*profile3.*,2,SAOPSettings.*1.*",
                                "AllPermutationsLearnSettings.*party1.*party2.*,false,.*profile1.*profile2.*profile3.*profile1.*,2,SAOPSettings.*1.*",
                                "AllPermutationsLearnSettings.*party1.*party2.*,false,.*profile1.*profile2.*profile3.*,2,SAOPSettings.*2.*");
        }

        @Test
        public void getProtocolTest() {
                assertEquals("APPLearn",
                                settings.getProtocol(new ReportToLogger("test")).getRef()
                                                .getURI().toString());
        }

        @Test
        public void testDeserialize() throws IOException {
                TournamentSettings obj = (TournamentSettings) jackson
                                .readValue(serialized, NegoSettings.class);
                System.out.println(obj);
                assertEquals(settings, obj);
        }

        @Test
        public void testSerialize()
                        throws JsonProcessingException, URISyntaxException {

                String string = jackson.writeValueAsString(settings);
                System.out.println(string);
                assertEquals(serialized, string);
        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testNullParties() {
                new AllPermutationsLearnSettings(null,
                                Arrays.asList(profiles1, profiles2, profiles3, profiles1), true,
                                2, saopsettings, 1, learnsettings);

        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testNoParties() {
                new AllPermutationsLearnSettings(Collections.emptyList(),
                                Arrays.asList(profiles1, profiles2, profiles3, profiles1), true,
                                2, saopsettings, 1, learnsettings);

        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testNullProfiles() {
                new AllPermutationsLearnSettings(parties, null, true, 2, saopsettings,
                                1, learnsettings);

        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testInsufficientProfiles() {
                new AllPermutationsLearnSettings(parties,
                                Arrays.asList(profiles1, profiles2, profiles3, profiles1), true,
                                4, saopsettings, 1, learnsettings);

        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testNullSessionSettings() {
                new AllPermutationsLearnSettings(parties,
                                Arrays.asList(profiles1, profiles2, profiles3, profiles1), true,
                                4, null, 1, learnsettings);

        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testOnePartyPerSession() {
                new AllPermutationsLearnSettings(parties,
                                Arrays.asList(profiles1, profiles2, profiles3, profiles1), true,
                                1, saopsettings, 1, learnsettings);

        }

        @Test
        public void getPermutationsTest() {
                // #permutations + 1 training session
                assertEquals(7, settings.permutations().size().intValue());
                // 2* settings because 2 tournaments
                assertEquals(14, settings5.permutations().size().intValue());
        }

        /**
         * Test the learn session
         */
        @Test
        public void testGetlearnSessions() {
                // particularly we want to test where numparties does not match
                // numteamspersession
                AllPermutationsLearnSettings settings3parties = new AllPermutationsLearnSettings(
                                parties3, profiles, false, 2, saopsettings, 2, learnsettings);
                ImmutableList<SessionSettings> perms = settings3parties.permutations();
                // 3 parties, 3 profiles, 2 parties per session, = 18 , + 1 learn, *2
                // tournaments
                assertEquals(38, perms.size().intValue());

                // get the last setting, which must be a LearnSetting.
                LearnSettings learnsetting = (LearnSettings) perms
                                .get(BigInteger.valueOf(37));
                assertEquals(3, learnsetting.getAllParties().size());
                Parameters party1params = learnsetting.getAllParties().get(0).getParty()
                                .getParameters();
                assertEquals("a48b8bc9-4275-4a4e-bee9-6c0a734dc99a",
                                party1params.get("persistentstate").toString());
                List negodata = (List) party1params.get("negotiationdata");
                assertEquals(12, negodata.size());
        }

        @Test
        public void getMaxRuntimeTest() {
                assertEquals((Double) (6d * (10 + 2) + 99d), settings.getMaxRunTime());
        }

}