source: src/test/java/exampleagentstest/AgentTest.java

package exampleagentstest;

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

import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Random;

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

import genius.core.AgentID;
import genius.core.Bid;
import genius.core.DomainImpl;
import genius.core.Global;
import genius.core.actions.Accept;
import genius.core.actions.Action;
import genius.core.actions.EndNegotiation;
import genius.core.actions.Offer;
import genius.core.exceptions.InstantiateException;
import genius.core.issue.Issue;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.IssueInteger;
import genius.core.issue.IssueReal;
import genius.core.issue.Value;
import genius.core.issue.ValueInteger;
import genius.core.issue.ValueReal;
import genius.core.parties.NegotiationInfo;
import genius.core.parties.NegotiationParty;
import genius.core.persistent.PersistentDataContainer;
import genius.core.timeline.TimeLineInfo;
import genius.core.utility.AbstractUtilitySpace;
import genius.core.utility.AdditiveUtilitySpace;

/**
 * Test an example agent: try to load it, init it etc.
 */
public abstract class AgentTest {

        private NegotiationParty party;
        private Class<? extends NegotiationParty> partyclass;
        private final String PARTY = "src/test/resources/partydomain/";
        List<Class<? extends Action>> actions = Arrays.asList(Accept.class,
                        Offer.class, EndNegotiation.class);
        private NegotiationInfo info;
        protected PersistentDataContainer persistentData;
        private AbstractUtilitySpace utilspace;
        private Random rand = new Random();

        public AgentTest(Class<? extends NegotiationParty> partyclass) {
                this.partyclass = partyclass;
        }

        @Before
        public void before() throws InstantiateException, IOException {
                party = (NegotiationParty) Global
                                .loadObject(partyclass.getCanonicalName());

                info = mock(NegotiationInfo.class);
                when(info.getAgentID()).thenReturn(new AgentID("test"));
                persistentData = mock(PersistentDataContainer.class);
                when(info.getPersistentData()).thenReturn(persistentData);
                utilspace = createUtilSpace();
                when(info.getUtilitySpace()).thenReturn(utilspace);
                TimeLineInfo timeline = mock(TimeLineInfo.class);
                when(timeline.getTime()).thenReturn(0.2);
                when(info.getTimeline()).thenReturn(timeline);

        }

        @Test
        public void loadClassTest() throws InstantiateException {
        }

        @Test
        public void getDescriptionTest() {
                assertNotNull(party.getDescription());
        }

        @Test
        public void getProtocolTest() {
                assertNotNull(party.getProtocol());
        }

        @Test
        public void initTest() throws IOException {
                party.init(info);
        }

        @Test
        public void getActionTest() {
                party.init(info);
                party.chooseAction(actions);
        }

        @Test
        public void receiveMessageTest() {
                party.init(info);
                AgentID other = new AgentID("other");
                party.receiveMessage(other, new Offer(other, generateRandomBid()));
        }

        /**
         * this is tricky. We need a full-fledged utilspace as the agent gets
         * cracking on it. mocking that would be difficult.
         * 
         * @throws IOException
         */
        private AbstractUtilitySpace createUtilSpace() throws IOException {
                DomainImpl domain = new DomainImpl(PARTY + "party_domain.xml");
                return new AdditiveUtilitySpace(domain, PARTY + "party1_utility.xml");
        }

        protected Bid generateRandomBid() {
                try {
                        // Pairs <issue number, chosen value string>
                        HashMap<Integer, Value> values = new HashMap<Integer, Value>();

                        // For each issue, put a random value
                        for (Issue currentIssue : utilspace.getDomain().getIssues()) {
                                values.put(currentIssue.getNumber(),
                                                getRandomValue(currentIssue));
                        }

                        // return the generated bid
                        return new Bid(utilspace.getDomain(), values);

                } catch (Exception e) {

                        // return empty bid if an error occurred
                        return new Bid(utilspace.getDomain());
                }
        }

        /**
         * Gets a random value for the given issue.
         *
         * @param currentIssue
         *            The issue to generate a random value for
         * @return The random value generated for the issue
         * @throws Exception
         *             if the issues type is not Discrete, Real or Integer.
         */
        protected Value getRandomValue(Issue currentIssue) throws Exception {

                Value currentValue;
                int index;

                switch (currentIssue.getType()) {
                case DISCRETE:
                        IssueDiscrete discreteIssue = (IssueDiscrete) currentIssue;
                        index = (rand.nextInt(discreteIssue.getNumberOfValues()));
                        currentValue = discreteIssue.getValue(index);
                        break;
                case REAL:
                        IssueReal realIss = (IssueReal) currentIssue;
                        index = rand.nextInt(realIss.getNumberOfDiscretizationSteps()); // check
                                                                                                                                                        // this!
                        currentValue = new ValueReal(realIss.getLowerBound()
                                        + (((realIss.getUpperBound() - realIss.getLowerBound()))
                                                        / (realIss.getNumberOfDiscretizationSteps()))
                                                        * index);
                        break;
                case INTEGER:
                        IssueInteger integerIssue = (IssueInteger) currentIssue;
                        index = rand.nextInt(integerIssue.getUpperBound()
                                        - integerIssue.getLowerBound() + 1);
                        currentValue = new ValueInteger(
                                        integerIssue.getLowerBound() + index);
                        break;
                default:
                        throw new Exception(
                                        "issue type " + currentIssue.getType() + " not supported");
                }

                return currentValue;
        }

}