source: src/test/java/negotiator/parties/NegoInfoTest.java@ 127

package negotiator.parties;

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

import java.util.ArrayList;
import java.util.List;

import javax.swing.table.AbstractTableModel;

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

import genius.core.Bid;
import genius.core.Domain;
import genius.core.issue.Issue;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.Objective;
import genius.core.issue.ValueDiscrete;
import genius.core.utility.AdditiveUtilitySpace;
import genius.core.utility.EvaluatorDiscrete;

public class NegoInfoTest {

        private AdditiveUtilitySpace utilspace;
        private Domain domain;
        private List<Issue> issues = new ArrayList<Issue>();

        @Before
        public void before() {
                // the absolute minimum mocks
                utilspace = mock(AdditiveUtilitySpace.class);
                domain = mock(Domain.class);
                when(utilspace.getDomain()).thenReturn(domain);
        }

        @Test
        public void testConstructorNoIssues() throws Exception {
                // smoke test with minimal config.
                NegoInfo model = new NegoInfo(new Bid(domain), new Bid(domain),
                                utilspace);
                checkConsistency(model);
        }

        @Test
        public void testConstructor2Issues() throws Exception {
                addTwoIssues();
                NegoInfo model = new NegoInfo(new Bid(domain), new Bid(domain),
                                utilspace);
                checkConsistency(model);
        }

        /****************** support ***********************/
        private void addTwoIssues() {
                when(utilspace.getEvaluator(anyInt())).thenReturn(
                                mock(EvaluatorDiscrete.class));

                issues.add(issue());
                issues.add(issue());

                Objective objectivesRoot = mock(Objective.class);
                Objective objective = mock(Objective.class);

                when(domain.getObjectivesRoot()).thenReturn(objectivesRoot);
                when(objectivesRoot.getObjective(anyInt())).thenReturn(objective);

                when(domain.getIssues()).thenReturn(issues);

        }

        private static int nr = 1;

        Issue issue() {
                IssueDiscrete issue = mock(IssueDiscrete.class);
                when(issue.getNumber()).thenReturn(nr++);
                when(issue.getValues()).thenReturn(value());
                return issue;
        }

        private List<ValueDiscrete> value() {
                ArrayList<ValueDiscrete> values = new ArrayList<ValueDiscrete>();
                for (int n = 0; n < 3; n++) {
                        ValueDiscrete value = mock(ValueDiscrete.class);
                        values.add(value);
                }
                return values;
        }

        private void checkConsistency(AbstractTableModel model) {
                for (int col = 0; col < model.getColumnCount(); col++) {
                        assertNotNull(model.getColumnName(col));
                        for (int row = 0; row < model.getRowCount(); row++) {
                                assertNotNull("model value in row " + row + ", column " + col
                                                + " is not set", model.getValueAt(row, col));
                        }
                }
        }
}