source: protocol/src/test/java/geniusweb/protocol/session/ConnectionWithPartiesTest.java

package geniusweb.protocol.session;

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.util.Arrays;
import java.util.List;

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

import geniusweb.actions.PartyId;
import geniusweb.protocol.partyconnection.ProtocolToPartyConnections;
import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
import tudelft.utilities.junit.GeneralTests;

public class ConnectionWithPartiesTest
                extends GeneralTests<ProtocolToPartyConnections> {
        PartyId party1 = new PartyId("party1");
        PartyId party2 = new PartyId("party2");
        PartyId party3 = new PartyId("party3");

        private ProtocolToPartyConn con1 = mock(ProtocolToPartyConn.class);
        private ProtocolToPartyConn con2 = mock(ProtocolToPartyConn.class);
        private ProtocolToPartyConn con3 = mock(ProtocolToPartyConn.class);

        private ProtocolToPartyConnections conns1 = new ProtocolToPartyConnections(
                        Arrays.asList(con1, con2));
        private ProtocolToPartyConnections conns1a = new ProtocolToPartyConnections(
                        Arrays.asList(con1, con2));
        private ProtocolToPartyConnections conns2 = new ProtocolToPartyConnections(
                        Arrays.asList(con1, con3));
        private ProtocolToPartyConnections conns3 = new ProtocolToPartyConnections(
                        Arrays.asList(con2, con1));
        private ProtocolToPartyConnections conns4 = new ProtocolToPartyConnections(
                        Arrays.asList(con2, con1, con3));
        private ProtocolToPartyConnections conns5 = new ProtocolToPartyConnections(
                        Arrays.asList(con2, con1, con3, con1));

        @Before
        public void before() {
                when(con1.toString()).thenReturn("con1");
                when(con2.toString()).thenReturn("con2");
                when(con3.toString()).thenReturn("con3");

                when(con1.getParty()).thenReturn(party1);
                when(con2.getParty()).thenReturn(party2);
                when(con3.getParty()).thenReturn(party3);

        }

        @Override
        public List<List<ProtocolToPartyConnections>> getGeneralTestData() {
                return Arrays.asList(Arrays.asList(conns1, conns1a),
                                Arrays.asList(conns2), Arrays.asList(conns3),
                                Arrays.asList(conns4));
        }

        @Override
        public List<String> getGeneralTestStrings() {
                return Arrays.asList("ConnectionWithParties\\[con1, con2\\]",
                                "ConnectionWithParties\\[con1, con3\\]",
                                "ConnectionWithParties\\[con2, con1\\]",
                                "ConnectionWithParties\\[con2, con1, con3\\]");
        }

        @Test
        public void getTest() {
                assertEquals(con1, conns1.get(0));
                assertEquals(con3, conns4.get(2));
        }

        @Test
        public void getPartyTest() {
                assertEquals(con1, conns1.get(party1));
                assertEquals(con1, conns4.get(party1));
                assertEquals(con2, conns1.get(party2));
                assertEquals(con2, conns3.get(party2));
                assertEquals(con2, conns4.get(party2));
        }

        @Test
        public void getUnknownPartyTest() {
                assertEquals(null, conns2.get(party2));
        }

        @Test
        public void sizeTest() {
                assertEquals(2, conns1.size());
                assertEquals(2, conns2.size());
                assertEquals(2, conns3.size());
                assertEquals(3, conns4.size());
        }

        @Test
        public void withPartyTest() {
                ProtocolToPartyConnections conns = conns3.with(con3);
                assertEquals(2, conns3.size());
                assertEquals(3, conns.size());
                assertEquals(conns4, conns);
        }

        @Test
        public void withExistingPartyTest() {
                conns4.with(con1);
                // no throw, default this is ok, it should be the protocol testing this.
        }

        @Test
        public void allUniqueTest() {
                assertTrue(conns4.allunique());
                assertFalse(conns5.allunique());
        }

}