Changeset 24 for protocol/src

protocol/src/main/java/geniusweb/protocol/NegoProtocol.java

-              r21
+              r24
 import geniusweb.protocol.partyconnection.ProtocolToPartyConnFactory;
 import geniusweb.protocol.session.SessionProtocol;
-import geniusweb.protocol.session.SessionSettings;
 import geniusweb.protocol.session.SessionState;
 import geniusweb.protocol.tournament.TournamentProtocol;
 …
+ *
  * A protocol is mutable because the incoming connections cause state changes.
+ * But it is recommended to push all changing properties into the state.
+ * But it is recommended to push changing properties into the state so that the
+ * complete state can be recovered and analysed.
  * <p>
  * Because a protocol contains an internal state, it can be used only once.
- * <p>
  * <p>
  * The protocol can emit a {@link CurrentState} event at any time. It should do
 …
  * which it can resolve received {@link Reference}s. <br>
  * First call to instances <b>must be</b>
  * {@link #start(SessionSettings, ConnectionFactory)}.
+ * {@link #start(ProtocolToPartyConnFactory)}.
+ *
  * <h2>Ensure time deadline</h2>
 …
  * The protocol also needs to keep an eye on the deadline and take appropriate
  * actions when the deadline is reached. <br>
- * A protocol should emit a {@link SessionEnded} or {@link TournamentEnded}
- * event when it is finished.
  * <p>
  * All protocol implementations must ensure that the deadline is kept and that
 …
          * <p>
+         *
+         * All errors are to be handled through {@link SessionState#getError()}
+         * except for plain {@link IllegalArgumentException}s. <br>
+         * All errors are to be handled through {@link SessionState#getResult()}
+         * except for bugs that use {@link RuntimeException} like
+         * {@link IllegalArgumentException}s. <br>
          * The protocol usually uses the incoming connections to keep running. It
          * does not need to run in a separate thread or so.

protocol/src/main/java/geniusweb/protocol/NegoState.java

-              r21
+              r24
 /**
+ * The current state of the session/tournament. Must be serializabl;e so that it
+ * can be restarted if a crash occurs.
+ * The current state of the session/tournament. Must be (de)serializabl;e so
+ * that it can be restarted if a crash occurs. Notice that this restart
+ * functionality is not yet available.
+ * <p>
+ * In general the state contains all the information to control the flow of the
+ * negotiation: who did what, are we finished, etc. This object may be stored to
+ * record the final result as well
  */
 @JsonAutoDetect(fieldVisibility = Visibility.ANY, getterVisibility = Visibility.NONE, setterVisibility = Visibility.NONE, isGetterVisibility = Visibility.NONE)

protocol/src/main/java/geniusweb/protocol/ProtocolException.java

-              r21
+              r24
 /**
+ * thrown if a {@link Party} violates the protocols (that includes
+ * disconnecting).
+ * thrown if a Party violates the protocols (that includes disconnecting).
  */
 public class ProtocolException extends Exception {

protocol/src/main/java/geniusweb/protocol/partyconnection/ProtocolToPartyConnections.java

-              r21
+              r24
         /**
+         * Broadcast info to all parties
+         * Broadcast info to all parties. Notice that the broadcast immediately
+         * aborts if an error occurs and remaining parties will not receive the
+         * event. Therefore it is recommended to instead send to all parties
+         * individually to ensure all parties are handled individually.
+         *
          * @param info the {@link Inform} to broadcast
+         * @throws IOException if the send fails.
          */
         public void broadcast(Inform info) throws IOException {
 …
         /**
          * @param i
+         * @param i the connection number
          * @return the ith connection
          */

protocol/src/main/java/geniusweb/protocol/session/SessionResult.java

-              r23
+              r24
         /**
          * 8return the final {@link Agreements} of the session. May be empty, not
          * null
+         * @return the final {@link Agreements} of the session. May be empty, not
+         *         null
          */
         public Agreements getAgreements() {

protocol/src/main/java/geniusweb/protocol/session/SessionState.java

-              r21
+              r24
  * and the parties currently connected. <br>
  * The state checks if transitions (Actions from the party) are following the
+ * protocol, and thus implement most of the protocol . See
+ * {@link #with(geniusweb.actions.PartyId, Action)}. <br>
+ *
+ * Use {@link #with(geniusweb.actions.PartyId, Action)} and
+ * {@link #with(geniusweb.actions.PartyId, tudelft.utilities.connection.Connection)}
+ * to create a new state <br>
+ *
+ * protocol, and thus implement most of the protocol . <br>
+ *
  * If protocol errors occur, these should be stored in the state and the state
  * should become {@link #isFinal()}. Throwing should happen only in case of a
  * bug.<br>
+ * should become {@link #isFinal(long)}. Throwing should happen only in case of
+ * a bug.<br>
+ *
  * Implementations should be immutable (to ensure thread safety, testability
 …
          * @return the current standing agreement, or null if there is no agreement
          *         at this point. An agreement does not necessarily mean
          *         {@link #isFinal()}.
+         *         {@link #isFinal(long)}.
          */
         Agreements getAgreements();
 …
         /**
+         *
+         * @return the {@link SessionResult}. Assumes {@link #isFinal(long)}. result
+         *         may be undefined if not.
+         * @return the {@link SessionResult} which is a short report of the final
+         *         outcome. Assumes {@link #isFinal(long)}. result may be undefined
+         *         if not.
          */
         SessionResult getResult();

protocol/src/main/java/geniusweb/protocol/session/amop/AMOP.java

-              r21
+              r24
 import geniusweb.protocol.CurrentNegoState;
 import geniusweb.protocol.ProtocolException;
-import geniusweb.protocol.WillBeCalled;
 import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
 import geniusweb.protocol.partyconnection.ProtocolToPartyConnFactory;
 …
  * <h1>parameter</h1> AMOP parties can receive a parameter: minVotes containing
  * a Double. If set, the AMOP protocol checks that all {@link Votes} from that
+ * party have {@link Vote#getMinPower()} > minVotes.
+ * <h1>Protocol steps</h1> The protocol tries to start all parties. If not all
+ * parties start, the parties are freed up and another attempt is done to start
+ * all parties some time later.
+ * party have {@link Vote#getMinPower()} &gt; minVotes.
+ * <h1>Protocol steps</h1>
+ * <ol>
+ * <li>The protocol tries to start all parties. If not all parties start, the
+ * parties are freed up and another attempt is done to start all parties some
+ * time later.
  * <li>the variable remainingparties = {all parties}
  * <li>The session deadline clock now starts ticking.
  * <li>All parties are sent their settings.
  * <li>Loop until {@link Deadline} is reached or |remainingparties|<2:
+ * <li>Loop until {@link Deadline} is reached or |remainingparties|&lt;2:
  * <ol>
  * <li>protocol sends {@link YourTurn} to all remainingparties. Each party now
  * must submit an {@link Offer} within {@link #PHASE_TIME} seconds. If a party
  * fails to submit it is send Finished and removed from from remainingparties.
  * <li>protocol sends a {@link Voting} containing a List<Bid> containing all
  * received {@link Bid}s. Each party must place his {@link Votes} within
  * {@link #PHASE_TIME} seconds. If a party does not submit, it is send a
+ * <li>protocol sends a {@link Voting} containing a List of {@link Bid}
+ * containing all received {@link Bid}s. Each party must place his {@link Votes}
+ * within {@link #PHASE_TIME} seconds. If a party does not submit, it is send a
  * {@link Finished} and removed from remainingparties. Previous votes for the
  * same bid do not count. But see {@link Agreements}.
  * <li>The protocol determines a maximum sized subset of size N>=2 of the votes
  * for bid B for which the vote conditions hold. If there is such a subset, the
  * parties that placed these votes reached an agreement. They are added to the
  * agreement set, sent the {@link Finished} info and terminated. They are
  * removed from the remainingparties.
+ * <li>The protocol determines a maximum sized subset of size N&ge;2 of the
+ * votes for bid B for which the vote conditions hold. If there is such a
+ * subset, the parties that placed these votes reached an agreement. They are
+ * added to the agreement set, sent the {@link Finished} info and terminated.
+ * They are removed from the remainingparties.
  * </ol>
  * <li>Any remaining parties are sent a {@link Finished} object without
 …
         /**
+         *
+         * @param state normally the initial state coming from SAOPSettings
+         * @param state  normally the initial state coming from SAOPSettings
+         * @param logger the {@link Reporter} to use
          */
         public AMOP(AMOPState state, Reporter logger) {
 …
          * overridable factory method, used for testing.
+         *
          * @param r
          * @param delayMs
+         * @param r       the {@link Runnable} that will be called
+         * @param delayMs the time after which r will be called
          * @return new WillBeCalled(r,delayms)
          */

protocol/src/main/java/geniusweb/protocol/session/amop/AMOPSettings.java

-              r21
+              r24
          *                     protocol. But SAOP can be initialized with less, for
          *                     use in TournamentSettings.
+         * @param deadline
+         * @param minimumVotes the minimum number of votes allowed for a bid.
+         * @param deadline     the {@link Deadline} of the negotiation
          */
         @JsonCreator

protocol/src/main/java/geniusweb/protocol/session/amop/AMOPState.java

-              r23
+              r24
         /**
+         * @param actor         the actor that did this action. Can be used to check
+         *                      if action is valid. NOTICE caller has to make sure
+         *                      the current state is not final. MUST NOT be null.
+         * @param action        the action that was proposed by actor. MUST NOT be
+         *                      null.
+         * @param currentTimeMs the current time in ms since 1970, see
+         *                      {@link System#currentTimeMillis()}
+         * @param actor  the actor that did this action. Can be used to check if
+         *               action is valid. NOTICE caller has to make sure the current
+         *               state is not final. MUST NOT be null.
+         * @param action the action that was proposed by actor. MUST NOT be null.
          * @return new SessionState with the action added as last action.
          * @throws ProtocolException if actor is violating the protocol

protocol/src/main/java/geniusweb/protocol/session/mopac/MOPAC.java

-              r23
+              r24
 import java.io.IOException;
+import java.util.Collections;
 import java.util.List;
 import java.util.Timer;
 …
  * parties are freed up and another attempt is done to start all parties some
  * time later.
- * <li>the variable remainingparties = {all parties}
  * <li>The session deadline clock now starts ticking.
  * <li>remainingparties are sent their settings.
  * <li>Loop until {@link Deadline} is reached or |remainingparties|<2:
+ * <li>Loop until {@link Deadline} is reached or |remainingparties| &le; 2:
  * <ol>
  * <li>protocol sends {@link YourTurn} to all remainingparties. Each party now
  * must submit an {@link Offer} within {@link Phase#PHASE_MAXTIME} seconds. If a
  * party fails to submit it is removed from from remainingparties.
  * <li>protocol sends a {@link Voting} containing a List<Bid> containing all
  * received {@link Bid}s. Each party must place his {@link Votes} within
  * {@link #PHASE_TIME} seconds. If a party does not submit, it is terminated and
  * removed from remainingparties. Previous votes for the same bid do not count.
  * But see {@link Agreements}. A party that misbehaves after submitting its vote
  * is removed but it Votes remain standing.
+ * <li>protocol sends a {@link Voting} containing a List of Bid containing all
+ * received {@link Bid}s. Each party must place his {@link Votes} within the
+ * provided deadline. If a party does not submit, it is terminated and removed
+ * from remainingparties. Previous votes for the same bid do not count. But see
+ * {@link Agreements}. A party that misbehaves after submitting its vote is
+ * removed but it Votes remain standing.
  * <li>protocol sends to all remainingparties a OptIn containing all received
  * votes. Each party now must submit again a {@link Votes} object within
  * {@link #PHASE_TIME} seconds. This new Votes must equal or extend the previous
  * Votes of the party.
  * <li>The protocol use the {@link MOPACState#getEvaluator()} to determine the
  * ... . If there is such a subset, the parties that placed these votes reached
  * an agreement. They are added to the agreement set, sent the {@link Finished}
  * info and terminated. They are removed from the remainingparties.
+ * votes. Each party now must submit again a {@link Votes} object within the
+ * deadline. This new Votes must equal or extend the previous Votes of the
+ * party.
+ * <li>The protocol uses the {@link Phase#getEvaluator()} to determine the
+ * agreements from the votes. If there are agreements, the parties that placed
+ * these votes reached an agreement. They are moved to the agreement set and
+ * removed from the remainingparties.
  * </ol>
  * <li>Any remaining parties are sent a {@link Finished} object without
 …
         private final Reporter log;
         private MOPACState state = null; // mutable!
+        /**
+         * the existing party connections. we assume ownership of this so it should
+         * not be modified although connections may of course break. mutable!
+         */
+        private ProtocolToPartyConnections connections = new ProtocolToPartyConnections(
+                        Collections.emptyList());
         /**
 …
         /**
+         *
+         * @param state normally the initial state coming from SAOPSettings
+         * @param state  normally the initial state coming from SAOPSettings
+         * @param logger the {@link Reporter} to use
          */
         public MOPAC(MOPACState state, Reporter logger) {
 …
                         ProtocolToPartyConnFactory connectionfactory) {
                 try {
-                        // System.out.println("starting MOPAC");
-                        // we're in Phase.INIT still
                         connect(connectionfactory);
-                        setupParties();
-                        long now = System.currentTimeMillis();
-                        state = state.initPhase(now);
-                        startPhase(now);
                 } catch (Throwable e) {
+                        e.printStackTrace();
+                        handleError("Failed to start MOPAC session", new PartyId("BUG"), e);
+                }
+                        /** We can't {@link #handleError} yet. FIXME */
+                        throw new RuntimeException("Failed to connect", e);
+                }
+                long now = System.currentTimeMillis();
+                state = state.initPhase(
+                                ProgressFactory.create(state.getSettings().getDeadline(), now),
+                                now);
+                setupParties(now);
+                startPhase(now);
+        }
 …
                                 .map(parti -> (parti.getParty().getPartyRef()))
                                 .collect(Collectors.toList());
-                List<ProtocolToPartyConn> connections = null;
                 log.log(Level.INFO, "MOPAC connect " + parties);
+                while (connections == null) {
+                List<ProtocolToPartyConn> newconnections = null;
+                while (newconnections == null) {
                         try {
                                 connections = connectionfactory.connect(parties);
+                                newconnections = connectionfactory.connect(parties);
                         } catch (NoResourcesNowException e) {
                                 long waitms = e.getLater().getTime()
 …
+                }
                 for (int i = 0; i < participants.size(); i++) {
+                        state = state.with(connections.get(i), participants.get(i));
+                        ProtocolToPartyConn conn = newconnections.get(i);
+                        connections = connections.with(conn);
+                        state = state.with(conn.getParty(), participants.get(i));
+                }
+        }
 …
          * part of the interface.
+         *
+         * @throws ProtocolException if a party does not follow the protocol
+         */
+        protected synchronized void setupParties() throws ProtocolException {
+                for (ProtocolToPartyConn conn : state.getConnections()) {
+                        conn.addListener(action -> actionRequest(conn, action,
+                                        System.currentTimeMillis()));
+                }
+                Long now = System.currentTimeMillis();
+                state = state.with(
+                                ProgressFactory.create(state.getSettings().getDeadline(), now));
+                for (ProtocolToPartyConn connection : state.getConnections()) {
+         * @param now the current time.
+         */
+        protected synchronized void setupParties(long now) {
+                for (ProtocolToPartyConn conn : connections) {
+                        conn.addListener(action -> actionRequest(conn, action, now));
+                }
+                for (ProtocolToPartyConn connection : connections) {
                         try {
                                 sendSettings(connection);
 …
+                        }
+                }
+        }
 …
                                 .getNegotiatingParties()) {
                         try {
                                 state.getConnections().get(party).send(info);
+                                connections.get(party).send(info);
                         } catch (IOException e) {
+                                handleError("Party seems to have disconnected", party, e);
+                        }
+                }
+        }
+        /**
+         * Update state to include the given error and closes the party.
+         *
+         * @param message The message to attach to the error
+         * @param party   the party where the error occured
+         * @param e       the exception that occured.
+         */
+        private void handleError(final String message, final PartyId partyid,
+                        final Throwable e) {
+                if (e instanceof ProtocolException) {
+                        state = state.with((ProtocolException) e);
+                } else {
+                        state = state.with(new ProtocolException(message, partyid, e));
+                }
+                log.log(Level.WARNING,
+                                "MOPAC intercepted error from party " + partyid + ":" + message,
+                                e);
+        }
+//      /**
+//       * Sets the new state. If the new state is final, the finish-up procedure is
+//       * executed. All state changes go through here to ensure we check isFinal
+//       * before any state change.
+//       *
+//       * @param newstate the new state.
+//       */
+//      private synchronized void setState(MOPACState newstate) {
+//              long now = System.currentTimeMillis();
+//              if (state.isFinal(now)) {
+//                      endNegotiation();
+//                      return;
+//              }
+//
+//              this.state = newstate;
+//              if (newstate.isFinal(now)) {
+//                      endNegotiation();
+//              }
+//      }
+                                state = state.with(new ProtocolException(
+                                                "Party seems to have disconnected", party, e));
+                        }
+                }
+        }
         /**
 …
                 finished = true;
                 Finished info = new Finished(state.getAgreements());
                 for (ProtocolToPartyConn conn : state.getConnections()) {
+                for (ProtocolToPartyConn conn : connections) {
                         try {
                                 conn.send(info);

protocol/src/main/java/geniusweb/protocol/session/mopac/MOPACSettings.java

-              r21
+              r24
 /**
  * Settings for MOPAC negotiation. in MOPAC, each party may get a "power"
  * parameter containing an natural number >=1.
+ * parameter containing an natural number &le;1.
  */
 public class MOPACSettings implements SessionSettings {
 …
          * @param participants the list of {@link PartyWithProfile} in clockwise
          *                     order. There must be at least 2 to run the MOPAC
+         *                     protocol. But SAOP can be initialized with less, for
+         *                     use in TournamentSettings.
+         *
+         *                     All provided participants must
+         *
+         * @param deadline
+         * @param minimumVotes the minimum number of votes allowed for a bid.
+         *                     protocol. This is not tested in the constructor
+         *                     because this can be initialized with less, for use in
+         *                     TournamentSettings.
+         * @param deadline     the {@link Deadline} for the negotiation
+         * @param votingeval   the {@link VotingEvaluator} to use.
          */
         @JsonCreator
 …
         @Override
         public SessionSettings with(TeamOfPartiesAndProfiles party) {
+        public MOPACSettings with(TeamOfPartiesAndProfiles party) {
                 if (!(party instanceof OnePartyTeam))
                         throw new IllegalArgumentException(

protocol/src/main/java/geniusweb/protocol/session/mopac/MOPACState.java

-              r23
+              r24
 import geniusweb.progress.Progress;
 import geniusweb.progress.ProgressRounds;
+import geniusweb.protocol.NegoProtocol;
 import geniusweb.protocol.ProtocolException;
-import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
-import geniusweb.protocol.partyconnection.ProtocolToPartyConnections;
 import geniusweb.protocol.session.SessionResult;
 import geniusweb.protocol.session.SessionState;
 …
 import geniusweb.protocol.session.saop.SAOPSettings;
 import geniusweb.references.PartyWithProfile;
+import geniusweb.voting.VotingEvaluator;
+/**
+ * Keeps track of the current {@link Phase}. Adds initializing stuff and
+ * time/deadline checking. This state does not contain connections, this assumes
+ * that someone else handles (i.e. {@link NegoProtocol} that and the connections
+ * with the parties and that negotiation events are just pumped in from there.
+ * <p>
+ * This object is a bit tricky. It has two states
+ * <ol>
+ * <li>The initial state, where phase=null and connections are being made to all
+ * parties. At this point, problems can not be handled nicely yet because there
+ * are no PartyId's for problematic parties
+ * <li>The working state, where all parties are connected and all problems can
+ * be connected to an offending party.
+ * </ol>
+ */
 public class MOPACState implements SessionState {
         private final Phase phase;
+        private final Phase phase; // maybe null while initializing
         private final MOPACSettings settings;
         private final Map<PartyId, PartyWithProfile> partyprofiles;
-        private final ProtocolToPartyConnections connections;
         private final List<Action> actions;
         private final Progress progress;
 …
          */
         public MOPACState(MOPACSettings settings) {
+                this(null, Arrays.asList(),
+                                new ProtocolToPartyConnections(Collections.emptyList()), null,
+                                settings, Collections.emptyMap());
+                this(null, Arrays.asList(), null, settings, Collections.emptyMap());
+        }
 …
          *                      set something only after we have connections.
          * @param actions       the legal actions that have been done in the
+         *                      negotiation. A new-sub-list is added for each phase
+         *                      change. It is assumed that the last element of the
+         *                      list is the list with actions taken in the current
+         *                      phase. first action in first list is the oldest.
+         *                      This MUST NOT contain illegal actions. Parties doing
+         *                      illegal actions are killed and the offending action
+         *                      ends up in the stacktrace. Previous actions of
+         *                      crashed parties remain standing and valid.
+         * @param conns         the existing party connections. we assume ownership
+         *                      of this so it should not be modified although
+         *                      connections may of course break.
+         *                      negotiation. {@link PartyStates#getActions()} is
+         *                      called to collect the actions after the phase is
+         *                      finished.first action in list is the oldest. This
+         *                      will not contain actions that immediately led to an
+         *                      agreement, because {@link PartyStates} removes the
+         *                      actions that led to an agreement. This MUST NOT
+         *                      contain illegal actions. Parties doing illegal
+         *                      actions are killed and the offending action ends up
+         *                      in the stacktrace. Previous actions of crashed
+         *                      parties remain standing and valid.
          * @param progress      the {@link Progress} line. can be null if not yet
+         *                      known. This happens because during setup we first
+         *                      add all connections, and only when we have that we
+         *                      set the correct deadline.
+         *                      known. null happens because during initialization
+         *                      phase the protocol first add all connections. During
+         *                      this time, parties may already enter the
+         *                      failed/exception state.
          * @param settings      the {@link SAOPSettings}
          * @param partyprofiles map with the {@link PartyWithProfile} for connected
          *                      parties. null is equivalent to an empty map.
-         * @param evaluator     the {@link VotingEvaluator}
          */
         @JsonCreator
         protected MOPACState(@JsonProperty("phase") Phase phase,
                         @JsonProperty("actions") List<Action> actions,
-                        @JsonProperty("connections") ProtocolToPartyConnections conns,
                         @JsonProperty("progress") Progress progress,
                         @JsonProperty("settings") MOPACSettings settings,
 …
                 this.phase = phase;
                 this.actions = actions;
-                this.connections = conns;
                 this.progress = progress;
                 this.settings = settings;
 …
         /**
+         * Can be called after all connections are initialized.
+         *
+         * @param now current time ms since 1970
+         *
+         * @return state with the initial partystates set.
+         */
+        public MOPACState initPhase(long now) {
+                PartyStates partyStates = new PartyStates(getPowers());
+                Phase firstPhase = new OfferPhase(null, partyStates,
+                                now + getAvailablePhaseTime(now),
+                                settings.getVotingEvaluation());
+                return new MOPACState(firstPhase, actions, connections, progress,
+                                settings, partyprofiles);
+        }
+        @Override
+        public List<Action> getActions() {
+                return Collections.unmodifiableList(actions);
+        }
+        @Override
+        public Progress getProgress() {
+                return progress;
+        }
+        public Map<PartyId, PartyWithProfile> getPartyProfiles() {
+                return Collections.unmodifiableMap(partyprofiles);
+        }
+        /**
+         * @return all current/remaining active party connections. Finished/crashed
+         *         parties should be removed immediately.
+         */
+        public ProtocolToPartyConnections getConnections() {
+                return connections;
+        }
+        /**
+         * @param now current time ms since 1970
+         * @return the max possible duration in ms of the NEXT phase. Maybe 0 or
+         *         negative if past deadline.
+         */
+        private Long getAvailablePhaseTime(long now) {
+                // explicit check, to check also the round counts.
+                if (incrementProgress().isPastDeadline(now + Phase.PHASE_MINTIME))
+                        return 0l;
+                return Math.min(progress.getTerminationTime().getTime() - now,
+                                Phase.PHASE_MAXTIME);
+        }
+        /**
+         *
+         * @param connection   the new {@link ProtocolToPartyConn}
+         * @param partyprofile the {@link PartyWithProfile} that is associated with
+         *                     this state
+         * @return new {@link MOPACState} with the new connection added. This call
+         *         ignores the progress (does not check isFinal) because we uses
+         *         this during the setup where the deadline is not yet relevant.
+         */
+        protected MOPACState with(ProtocolToPartyConn connection,
+                        PartyWithProfile partyprofile) {
+                if (phase != null)
+                        throw new IllegalStateException(
+                                        "Adding connections only allowed while initializing");
+                ProtocolToPartyConnections newconns = getConnections().with(connection);
+                Map<PartyId, PartyWithProfile> newprofiles = new HashMap<>(
+                                partyprofiles);
+                newprofiles.put(connection.getParty(), partyprofile);
+                return new MOPACState(null, actions, newconns, progress, settings,
+                                newprofiles);
+        }
+        /**
+         * @param id the {@link PartyId} of the party that failed.
+         * @param e  the {@link ProtocolException} that occurred in the party
+         * @return a new state with the error set.
+         */
+        public MOPACState with(ProtocolException e) {
+                return new MOPACState(phase.with(e), actions, connections, progress,
+                                settings, partyprofiles);
+        }
+        /**
+         * Sets the progress for this session. Can be set only if progress=null.
+         * Should be set in INIT phase.
+         *
+         * @param newprogress the new progress
+         * @return new {@link MOPACState} with the progress set
+         */
+        public MOPACState with(Progress newprogress) {
+         * Sets the progress for this session and initial phase. Must be called
+         * after all parties have been connected with
+         * {@link #with(PartyId, PartyWithProfile)}.
+         *
+         * @param newprogress the initial {@link Progress} typically matching the
+         *                    settings deadline object
+         * @param now         current time ms since 1970
+         *
+         * @return state with the initial partystates , progress set.
+         */
+        public MOPACState initPhase(Progress newprogress, long now) {
                 if (progress != null || newprogress == null || phase != null) {
                         throw new IllegalArgumentException(
                                         "progress must be null, newprogress must be not null and phase must be INIT");
+                }
+                return new MOPACState(phase, actions, connections, newprogress,
+                                getSettings(), partyprofiles);
+                PartyStates partyStates = new PartyStates(getPowers());
+                Phase firstPhase = new OfferPhase(partyStates,
+                                now + getAvailablePhaseTime(newprogress, now),
+                                settings.getVotingEvaluation());
+                return new MOPACState(firstPhase, actions, newprogress, settings,
+                                partyprofiles);
+        }
+        @Override
+        public List<Action> getActions() {
+                return Collections.unmodifiableList(actions);
+        }
+        @Override
+        public Progress getProgress() {
+                return progress;
+        }
+        @Override
+        public Agreements getAgreements() {
+                return phase.getPartyStates().getAgreements();
+        }
+        @Override
+        public MOPACSettings getSettings() {
+                return settings;
+        }
+        public Map<PartyId, PartyWithProfile> getPartyProfiles() {
+                return Collections.unmodifiableMap(partyprofiles);
+        }
+        @Override
+        public boolean isFinal(long now) {
+                return phase != null && phase.isFinal(now) && !isNewPhasePossible(now);
+        }
+        @Override
+        public SessionResult getResult() {
+                return new SessionResult(partyprofiles, getAgreements(),
+                                Collections.emptyMap(), null);
+        }
+        /**
+         * @param progress the Progress that needs to be checked
+         * @param now      current time ms since 1970
+         * @return the max possible duration in ms of a phase considering the
+         *         progress.
+         */
+        private static Long getAvailablePhaseTime(Progress aprogress, long now) {
+                return Math.min(aprogress.getTerminationTime().getTime() - now,
+                                Phase.PHASE_MAXTIME);
+        }
+        /**
+         * @param id           the new {@link PartyId}
+         * @param partyprofile the {@link PartyWithProfile} that is associated with
+         *                     this state
+         * @return new {@link MOPACState} with the new party added. This call
+         *         ignores the progress (does not check isFinal) because we uses
+         *         this during the setup where the deadline is not yet relevant.
+         */
+        protected MOPACState with(PartyId id, PartyWithProfile partyprofile) {
+                if (phase != null)
+                        throw new IllegalStateException(
+                                        "Adding connections only allowed while initializing");
+                Map<PartyId, PartyWithProfile> newprofiles = new HashMap<>(
+                                partyprofiles);
+                newprofiles.put(id, partyprofile);
+                return new MOPACState(null, actions, progress, settings, newprofiles);
+        }
+        /**
+         * @param e the {@link ProtocolException} that occured
+         * @return a new state with the error set. You MUST have called
+         *         {@link #initPhase(Progress, long)} before using this
+         */
+        public MOPACState with(ProtocolException e) {
+                return new MOPACState(phase.with(e), actions, progress, settings,
+                                partyprofiles);
+        }
 …
                                 Math.min(remainingNegoTime, Phase.PHASE_MAXTIME));
+                return new MOPACState(newphase, actions, connections,
+                                incrementProgress(), getSettings(), partyprofiles);
+        }
+        /**
+         *
+         * @return the next progress. Progress round advances if phase is
+         *         {@link OptIn}.
+         */
+        private Progress incrementProgress() {
+                if (progress instanceof ProgressRounds && phase instanceof OptInPhase)
+                        return ((ProgressRounds) progress).advance();
+                return progress;
+        }
+        @Override
+        public boolean isFinal(long now) {
+                return phase != null && phase.isFinal(now) && !isNewPhasePossible(now);
+                return new MOPACState(newphase, actions, increment(progress, phase),
+                                getSettings(), partyprofiles);
+        }
 …
          * When this is called, all parties should have acted.
+         *
+         * @param now
+         * @return
+         * @param now current time
+         * @return true if there are still &gt;2 parties active and we have enough
+         *         time for a new phase.
          */
         public boolean isNewPhasePossible(long now) {
                 // System.out.println("phase=" + phase);
+                boolean a = phase.getPartyStates().getNegotiatingParties().size() >= 2
+                                && getAvailablePhaseTime(now) > Phase.PHASE_MINTIME;
+                // System.out.println("newstate possible:" + a);
+                return a;
+        }
+        @Override
+        public Agreements getAgreements() {
+                return phase.getPartyStates().getAgreements();
+        }
+        @Override
+        public MOPACSettings getSettings() {
+                return settings;
+                Progress newprogress = increment(progress, phase);
+                if (newprogress.isPastDeadline(now + Phase.PHASE_MINTIME))
+                        return false;
+                return phase.getPartyStates().getNegotiatingParties().size() >= 2
+                                && getAvailablePhaseTime(newprogress,
+                                                now) > Phase.PHASE_MINTIME;
+        }
 …
          * @param now    the current time in ms since 1970, see
          *               {@link System#currentTimeMillis()}
+         * @return new {@link MOPACState} with the action checked and registered. If
+         *         the action is not allowed, the new state may be that the actor is
+         *         in the exception list.
          */
         public MOPACState with(PartyId actor, Action action, long now) {
+                return new MOPACState(phase.with(actor, action, now), actions,
+                                connections, progress, settings, partyprofiles);
+        }
+        @Override
+        public SessionResult getResult() {
+                return new SessionResult(partyprofiles, getAgreements(),
+                                Collections.emptyMap(), null);
+                return new MOPACState(phase.with(actor, action, now), actions, progress,
+                                settings, partyprofiles);
+        }
+        /**
+         * @param aprogress the progress that might need to be advanced
+         * @param aphase    the phase
+         * @return the next progress. Progress round advances if phase is
+         *         {@link OptIn}.
+         */
+        private static Progress increment(Progress aprogress, Phase aphase) {
+                if (aprogress instanceof ProgressRounds && aphase instanceof OptInPhase)
+                        return ((ProgressRounds) aprogress).advance();
+                return aprogress;
+        }
 …
         public String toString() {
                 return "MOPACState[" + phase + "," + settings + "," + partyprofiles
                                 + "," + connections + "," + progress + "," + "]";
+                                + "," + progress + "]";
+        }
 …
                 LinkedList<Action> newactions = new LinkedList<Action>(actions);
                 newactions.addAll(newphase.getPartyStates().getActions());
+                return new MOPACState(newphase, newactions, connections, progress,
+                                settings, partyprofiles);
+                return new MOPACState(newphase, newactions, progress, settings,
+                                partyprofiles);
+        }
+        @Override
+        public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result + ((actions == null) ? 0 : actions.hashCode());
+                result = prime * result
+                                + ((partyprofiles == null) ? 0 : partyprofiles.hashCode());
+                result = prime * result + ((phase == null) ? 0 : phase.hashCode());
+                result = prime * result
+                                + ((progress == null) ? 0 : progress.hashCode());
+                result = prime * result
+                                + ((settings == null) ? 0 : settings.hashCode());
+                return result;
+        }
+        @Override
+        public boolean equals(Object obj) {
+                if (this == obj)
+                        return true;
+                if (obj == null)
+                        return false;
+                if (getClass() != obj.getClass())
+                        return false;
+                MOPACState other = (MOPACState) obj;
+                if (actions == null) {
+                        if (other.actions != null)
+                                return false;
+                } else if (!actions.equals(other.actions))
+                        return false;
+                if (partyprofiles == null) {
+                        if (other.partyprofiles != null)
+                                return false;
+                } else if (!partyprofiles.equals(other.partyprofiles))
+                        return false;
+                if (phase == null) {
+                        if (other.phase != null)
+                                return false;
+                } else if (!phase.equals(other.phase))
+                        return false;
+                if (progress == null) {
+                        if (other.progress != null)
+                                return false;
+                } else if (!progress.equals(other.progress))
+                        return false;
+                if (settings == null) {
+                        if (other.settings != null)
+                                return false;
+                } else if (!settings.equals(other.settings))
+                        return false;
+                return true;
+        }

protocol/src/main/java/geniusweb/protocol/session/mopac/PartyStates.java

-              r21
+              r24
 package geniusweb.protocol.session.mopac;
-import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 …
 import java.util.stream.Collectors;
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import geniusweb.actions.Action;
 import geniusweb.actions.EndNegotiation;
 …
 /**
  * The current state of all participating parties. A party either notYetActed,
  * did action, reached an agreement, walked away or made a
+ * Invariant: contains the current state of all participating parties. A party
+ * either notYetActed, did action, reached an agreement, walked away or made a
  * {@link ProtocolException}.
  * <p>
 …
  * agreements and move remaining parties back to notYetActed.
+ *
- * This is not considering current time or checking actions.
  */
+@JsonAutoDetect(fieldVisibility = Visibility.ANY, getterVisibility = Visibility.NONE, setterVisibility = Visibility.NONE, isGetterVisibility = Visibility.NONE)
 public class PartyStates {
         // all parties must be in exactly one state at all times.
 …
         private final List<PartyId> walkedAway;
         private final Map<PartyId, ProtocolException> exceptions;
+        private Map<PartyId, Integer> powers;
+        private final Map<PartyId, Integer> powers;
+        @JsonCreator
+        protected PartyStates(@JsonProperty("notYetActed") Set<PartyId> notYetActed,
+                        @JsonProperty("actions") List<Action> actions,
+                        @JsonProperty("agreements") Agreements agreements,
+                        @JsonProperty("walkedAway") List<PartyId> walkedAway,
+                        @JsonProperty("exceptions") Map<PartyId, ProtocolException> exceptions,
+                        @JsonProperty("powers") Map<PartyId, Integer> powers) {
+                this.notYetActed = notYetActed;
+                this.actions = actions;
+                this.agreements = agreements;
+                this.walkedAway = walkedAway;
+                this.exceptions = exceptions;
+                this.powers = powers;
+        }
         /**
 …
+        }
+        public PartyStates(Set<PartyId> notYetActed, List<Action> actions,
+                        Agreements agreements, List<PartyId> walkedAway,
+                        Map<PartyId, ProtocolException> exceptions,
+                        Map<PartyId, Integer> powers) {
+                this.notYetActed = notYetActed;
+                this.actions = actions;
+                this.agreements = agreements;
+                this.walkedAway = walkedAway;
+                this.exceptions = exceptions;
+                this.powers = powers;
+        }
+        /**
+         *
+         * @param action
+         * @return new state with party done given action.
+        /**
+         *
+         * @param action the action done by some party. The correctness of action,
+         *               particularly of {@link Action#getActor()}, must be correct.
+         * @return new state with party done given action. This just accepts any
+         *         given action and is not considering number of rounds, time or
+         *         whether an action is allowed.
+         *
          * @throws IllegalArgumentException if party doing action already acted.
          *                                  This is just a safety check as legality
 …
         /**
+         *
          * @param actor
          * @return {@link #notYetActed} with actor removed
+         */
+        private Set<PartyId> removeParty(PartyId actor) {
+                return removeParties(new HashSet<>(Arrays.asList(actor)));
+         * @throws IllegalArgumentException if party already acted (not in
+         *                                  {@link #notYetActed}).
+         */
+        private Set<PartyId> removeParty(PartyId party) {
+                Set<PartyId> newActiveParties = new HashSet<>(notYetActed);
+                if (!newActiveParties.remove(party))
+                        throw new IllegalArgumentException(
+                                        "Party " + party + " is not active, can't be removed");
+                return newActiveParties;
+        }
 …
         public Map<PartyId, ProtocolException> getExceptions() {
                 return Collections.unmodifiableMap(exceptions);
+        }
-        /**
+         *
-         * @param parties the parties to remove
-         * @return {@link #notYetActed} without the given parties.
-         */
-        private Set<PartyId> removeParties(Collection<PartyId> parties) {
-                Set<PartyId> newActiveParties = new HashSet<>(notYetActed);
-                for (PartyId party : parties) {
-                        if (!newActiveParties.remove(party))
-                                throw new IllegalArgumentException(
-                                                "Party " + party + " is not active, can't be removed");
+                }
-                return newActiveParties;
+        }
 …
         /**
+         * @param type the type of actions to extract
+         *
+         * @return all parties that walked away
+         */
+        public List<PartyId> getWalkedAway() {
+                return walkedAway;
+        }
+        /**
+         * @param <T>  the type of objects requested
+         * @param type the type of actions to extract. Must be of type T, needed
+         *             because of java's type erasure.
+         *
          * @return all actions of type done in this phase
          */
 …
+        }
+        @Override
+        public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result + ((actions == null) ? 0 : actions.hashCode());
+                result = prime * result
+                                + ((agreements == null) ? 0 : agreements.hashCode());
+                result = prime * result
+                                + ((exceptions == null) ? 0 : exceptions.hashCode());
+                result = prime * result
+                                + ((notYetActed == null) ? 0 : notYetActed.hashCode());
+                result = prime * result + ((powers == null) ? 0 : powers.hashCode());
+                result = prime * result
+                                + ((walkedAway == null) ? 0 : walkedAway.hashCode());
+                return result;
+        }
+        @Override
+        public boolean equals(Object obj) {
+                if (this == obj)
+                        return true;
+                if (obj == null)
+                        return false;
+                if (getClass() != obj.getClass())
+                        return false;
+                PartyStates other = (PartyStates) obj;
+                if (actions == null) {
+                        if (other.actions != null)
+                                return false;
+                } else if (!actions.equals(other.actions))
+                        return false;
+                if (agreements == null) {
+                        if (other.agreements != null)
+                                return false;
+                } else if (!agreements.equals(other.agreements))
+                        return false;
+                if (exceptions == null) {
+                        if (other.exceptions != null)
+                                return false;
+                } else if (!exceptions.equals(other.exceptions))
+                        return false;
+                if (notYetActed == null) {
+                        if (other.notYetActed != null)
+                                return false;
+                } else if (!notYetActed.equals(other.notYetActed))
+                        return false;
+                if (powers == null) {
+                        if (other.powers != null)
+                                return false;
+                } else if (!powers.equals(other.powers))
+                        return false;
+                if (walkedAway == null) {
+                        if (other.walkedAway != null)
+                                return false;
+                } else if (!walkedAway.equals(other.walkedAway))
+                        return false;
+                return true;
+        }
+}

protocol/src/main/java/geniusweb/protocol/session/mopac/phase/DefaultPhase.java

-              r23
+              r24
 package geniusweb.protocol.session.mopac.phase;
-import java.util.List;
-import java.util.stream.Collectors;
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import geniusweb.actions.Action;
 import geniusweb.actions.PartyId;
-import geniusweb.actions.Votes;
 import geniusweb.protocol.ProtocolException;
 import geniusweb.protocol.session.mopac.PartyStates;
 …
         protected final Long deadline;
         protected final PartyStates partyStates;
-        // don't serialize this, users don't need it..
-        @JsonIgnore
         protected final VotingEvaluator evaluator;
-        // don't serialize this, it will cause very large file
-        @JsonIgnore
-        protected final Phase prevPhase;
         /**
+         *
+         * @param actions     the actions done in this phase .
+         * @param prevPhase   the previous phase, can be used to collect previous
+         *                    votes etc.
+         * @param partyStates
+         * @param partyStates the {@link PartyStates}
          * @param deadline    deadline for this phase, ms since 1970
+         * @param evaluator   the {@link VotingEvaluator} to be used
          */
         public DefaultPhase(Phase prevPhase, PartyStates partyStates, Long deadline,
+        public DefaultPhase(PartyStates partyStates, Long deadline,
                         VotingEvaluator evaluator) {
                 this.partyStates = partyStates;
                 this.deadline = deadline;
-                this.prevPhase = prevPhase;
                 this.evaluator = evaluator;
+        }
 …
         /**
-         * @return all votes done in this phase.
-         */
-        public List<Votes> getVotes() {
-                return partyStates.getActions().stream()
-                                .filter(act -> act instanceof Votes).map(act -> (Votes) act)
-                                .collect(Collectors.toList());
+        }
-        /**
          * Check if actor can do given action. Basic checks:
          * <ul>
 …
          * </ul>
+         *
+         * @param activeParties the currently active parties
+         * @param actor
+         * @param action
+         * @param timems
+         * @throws ProtocolException
+         * @throw ProtocolException if the action violates the protocol, or null if
+         *        ok
+         * @param actor  the actor that really acted
+         * @param action the action that was done
+         * @param now    current time
+         * @throws ProtocolException if the action violates the protocol
          */
         protected void checkAction(PartyId actor, Action action, long timems)
+        protected void checkAction(PartyId actor, Action action, long now)
                         throws ProtocolException {
                 if (action == null)
 …
                                         "Incorrect actor info in action:" + action.getActor(),
                                         actor);
                 if (isFinal(timems))
+                if (isFinal(now))
                         throw new ProtocolException("passed deadline", actor);
                 if (!(getAllowedActions().contains(action.getClass())))
+                        throw new ProtocolException(
+                                        "Action not allowed in " + this.getClass() + ":" + action,
+                                        actor);
+                        throw new ProtocolException("Action not allowed in "
+                                        + this.getClass().getSimpleName() + ": " + action, actor);
                 if (!partyStates.getNotYetActed().contains(actor))
                         throw new ProtocolException("Actor can not act anymore", actor);
 …
         /**
-         * @param timems current time
          * @return current PartyStates
          */
 …
                         throw new IllegalArgumentException("Bug, illegal duration");
                 if (!isFinal(now))
+                        throw new IllegalStateException(
+                                        "next must only be called when phase isFinal");
+                if (!partyStates.getNotYetActed().isEmpty())
+                        throw new IllegalStateException("Bug. State has not been finished");
+                        throw new IllegalStateException("phase is not final");
                 return checkedNext(now + duration);
+        }
         /**
+         * As {@link #next(long, long)} but DefaultPhase already checked that 1.
+         * there is enough time for a next phase 2. current state is final 3.
+         *
          * @param deadline
+         * @param dl the deadline for the next phase (ms since 1970).
          * @return the next phase
          */
         protected abstract Phase checkedNext(long deadline);
+        protected abstract Phase checkedNext(long dl);
         @Override
         public String toString() {
-                // don't print prev state, it will give HUGE list because it also
-                // contains prevstate.....
                 return getClass().getSimpleName() + "[" + partyStates + "," + deadline
                                 + "," + evaluator + "]";
+        }
+        @Override
+        public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result
+                                + ((deadline == null) ? 0 : deadline.hashCode());
+                result = prime * result
+                                + ((evaluator == null) ? 0 : evaluator.hashCode());
+                result = prime * result
+                                + ((partyStates == null) ? 0 : partyStates.hashCode());
+                return result;
+        }
+        @Override
+        public boolean equals(Object obj) {
+                if (this == obj)
+                        return true;
+                if (obj == null)
+                        return false;
+                if (getClass() != obj.getClass())
+                        return false;
+                DefaultPhase other = (DefaultPhase) obj;
+                if (deadline == null) {
+                        if (other.deadline != null)
+                                return false;
+                } else if (!deadline.equals(other.deadline))
+                        return false;
+                if (evaluator == null) {
+                        if (other.evaluator != null)
+                                return false;
+                } else if (!evaluator.equals(other.evaluator))
+                        return false;
+                if (partyStates == null) {
+                        if (other.partyStates != null)
+                                return false;
+                } else if (!partyStates.equals(other.partyStates))
+                        return false;
+                return true;
+        }
+}

protocol/src/main/java/geniusweb/protocol/session/mopac/phase/OfferPhase.java

-              r23
+              r24
 import java.util.List;
 import java.util.stream.Collectors;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import geniusweb.actions.Action;
 …
 public class OfferPhase extends DefaultPhase {
+        public OfferPhase(Phase prevPhase, PartyStates partyStates, Long deadlinems,
+                        VotingEvaluator evaluator) {
+                super(prevPhase, partyStates, deadlinems, evaluator);
+        @JsonCreator
+        public OfferPhase(@JsonProperty("partyStates") PartyStates partyStates,
+                        @JsonProperty("deadlinems") Long deadlinems,
+                        @JsonProperty("evaluator") VotingEvaluator evaluator) {
+                super(partyStates, deadlinems, evaluator);
+        }
 …
                         return this.with(ex);
+                }
+                return new OfferPhase(prevPhase, partyStates.with(action), deadline,
+                                evaluator);
+                return new OfferPhase(partyStates.with(action), deadline, evaluator);
+        }
 …
         public OfferPhase with(ProtocolException e) {
                 System.out.println("Party kicked because of protocol exception:" + e);
+                return new OfferPhase(prevPhase, partyStates.with(e), deadline,
+                                evaluator);
+                return new OfferPhase(partyStates.with(e), deadline, evaluator);
+        }
         @Override
         public Phase finish() {
+                return new OfferPhase(prevPhase, partyStates.finish(), deadline,
+                                evaluator);
+                return new OfferPhase(partyStates.finish(), deadline, evaluator);
+        }
         @Override
         public VotingPhase checkedNext(long deadln) {
+                return new VotingPhase(this, partyStates.flush(), deadln, evaluator);
+                return new VotingPhase(getOffers(), partyStates.flush(), deadln,
+                                evaluator);
+        }
         public List<Bid> getOffers() {
+        protected List<Bid> getOffers() {
                 return partyStates.getActions(Offer.class).stream()
                                 .map(offer -> offer.getBid()).collect(Collectors.toList());

protocol/src/main/java/geniusweb/protocol/session/mopac/phase/OptInPhase.java

-              r23
+              r24
 import java.util.Map;
 import java.util.stream.Collectors;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import geniusweb.actions.Action;
 …
 public class OptInPhase extends DefaultPhase {
+        protected OptInPhase(Phase prevPhase, PartyStates partyStates,
+                        Long deadlinems, VotingEvaluator evaluator) {
+                super(prevPhase, partyStates, deadlinems, evaluator);
+        /**
+         * The votes received in the {@link VotingPhase}
+         */
+        private final List<Votes> votes;
+        @JsonCreator
+        protected OptInPhase(@JsonProperty("votes") List<Votes> votes,
+                        @JsonProperty("partyStates") PartyStates partyStates,
+                        @JsonProperty("deadlinems") Long deadlinems,
+                        @JsonProperty("evaluator") VotingEvaluator evaluator) {
+                super(partyStates, deadlinems, evaluator);
+                this.votes = votes;
+        }
         @Override
         public Inform getInform() {
                 return new OptIn(((VotingPhase) prevPhase).getVotes());
+                return new OptIn(votes);
+        }
 …
                         checkAction(actor, action, now);
                         if (action instanceof Votes)
                                 checkExtends(action);
+                                checkExtends((Votes) action);
                         return new OptInPhase(prevPhase, partyStates.with(action), deadline,
+                        return new OptInPhase(votes, partyStates.with(action), deadline,
                                         evaluator);
 …
          * Check that this action extends previous action.
+         *
+         * @param action
+         * @param phase
+         * @param newvotes new {@link Votes} just received
          * @throws ProtocolException if this action does not correctly extend
          *                           previous vote.
          */
+        private void checkExtends(Action action) throws ProtocolException {
+                Votes votes = (Votes) action;
+                PartyId actor = action.getActor();
+        private void checkExtends(Votes newvotes) throws ProtocolException {
+                PartyId actor = newvotes.getActor();
                 // this actor is active so he must have voted in previous round.
                 Votes prevVotes = ((VotingPhase) prevPhase).getVotes().stream()
                                 .filter(v -> v.getActor().equals(actor)).findFirst().get();
                 if (!(votes.isExtending(prevVotes)))
                         throw new ProtocolException("New votes " + action
+                Votes prevVotes = votes.stream().filter(v -> v.getActor().equals(actor))
+                                .findFirst().get();
+                if (!(newvotes.isExtending(prevVotes)))
+                        throw new ProtocolException("New votes " + newvotes
                                         + " does not extend previous vote " + prevVotes, actor);
+        }
 …
         @Override
         public OptInPhase with(ProtocolException e) {
+                return new OptInPhase(prevPhase, partyStates.with(e), deadline,
+                                evaluator);
+                return new OptInPhase(votes, partyStates.with(e), deadline, evaluator);
+        }
 …
                 PartyStates finalStates = states.with(newAgree);
                 return new OptInPhase(prevPhase, finalStates, deadline, evaluator);
+                return new OptInPhase(votes, finalStates, deadline, evaluator);
+        }
         @Override
         public OfferPhase checkedNext(long newdeadline) {
+                return new OfferPhase(this, partyStates.flush(), newdeadline,
+                                evaluator);
+                return new OfferPhase(partyStates.flush(), newdeadline, evaluator);
+        }

protocol/src/main/java/geniusweb/protocol/session/mopac/phase/Phase.java

-              r23
+              r24
 import java.util.List;
-import java.util.Set;
 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import geniusweb.actions.Action;
 …
  * A Phase is a part of the round structure. In each round parties have to take
  * multiple actions. Each action is part of a phase.
+ *
+ *
+ * Invariant: A phase object handles negotiation events, ensuring that the
+ * events are handled according to the possible actions in this phase. A phase
+ * object must always remain in a consistent state. It does so by modifying the
+ * contained {@link PartyStates} as needed.
+ * <p>
+ * The standard exception handling is assumed: unchecked exceptions are thrown
+ * only if there is a bug in the protocol. Because none of the functions in this
+ * interface throws, any error must be either ignored or the party must be
+ * kicked.
  */
+@JsonAutoDetect(fieldVisibility = Visibility.ANY, getterVisibility = Visibility.NONE, setterVisibility = Visibility.NONE)
+@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.WRAPPER_OBJECT)
+@JsonAutoDetect(fieldVisibility = Visibility.ANY, getterVisibility = Visibility.NONE, setterVisibility = Visibility.NONE, isGetterVisibility = Visibility.NONE)
+@JsonSubTypes({ @JsonSubTypes.Type(value = OfferPhase.class),
+                @JsonSubTypes.Type(value = OptInPhase.class),
+                @JsonSubTypes.Type(value = VotingPhase.class) })
 public interface Phase {
         public static final Long PHASE_MAXTIME = 30000l; // 30sec
 …
          * handled by updating the PartyStates
+         *
          * @param prevPhases the list of all previous phases
          * @param actor      the real actor
          * @param action     the action submitted by actor, which this phase can
          *                   really handle.
          * @param now        the current time
+         * @param actor  the real actor (may differ from the actor contained in the
+         *               action)
+         * @param action the action submitted by actor, which this phase can really
+         *               handle.
+         * @param now    the current time
          * @return new VotingPhase
          */
 …
          * after {@link #finish()}
+         *
          * @param now      the curren time
          * @param duration the max duration of the next phase. Must be between
+         * @param now      the current time
+         * @param duration the max duration (ms) of the next phase. Must be between
          *                 {@link #PHASE_MINTIME} and {@link #PHASE_MAXTIME}. Also
          *                 make sure that now+duration is at most at the total
 …
         /**
+         * Get the voting evaluator
+         *
+         * @return
+         * @return the voting evaluator
          */
         public VotingEvaluator getEvaluator();
 …
         /**
-         * @param now the current time
+         *
          * @return the party states. Notice that someone must call
          *         {@link PartyStates#finish(Set)} if passed the deadline.
+         *         {@link PartyStates#finish()} if passed the deadline.
          */
         public PartyStates getPartyStates();

protocol/src/main/java/geniusweb/protocol/session/mopac/phase/VotingPhase.java

-              r23
+              r24
 import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import geniusweb.actions.Action;
 …
 import geniusweb.inform.Inform;
 import geniusweb.inform.Voting;
+import geniusweb.issuevalue.Bid;
 import geniusweb.protocol.ProtocolException;
 import geniusweb.protocol.session.mopac.PartyStates;
 …
 public class VotingPhase extends DefaultPhase {
+        VotingPhase(Phase prevPhase, PartyStates partyStates, Long deadlinems,
+                        VotingEvaluator evaluator) {
+                super(prevPhase, partyStates, deadlinems, evaluator);
+        /**
+         * the offers received in the {@link OfferPhase}
+         */
+        private final List<Bid> offers;
+        @JsonCreator
+        protected VotingPhase(@JsonProperty("offers") List<Bid> offers,
+                        @JsonProperty("partyStates") PartyStates partyStates,
+                        @JsonProperty("deadlinems") Long deadlinems,
+                        @JsonProperty("evaluator") VotingEvaluator evaluator) {
+                super(partyStates, deadlinems, evaluator);
+                this.offers = offers;
+        }
 …
                         return this.with(ex);
+                }
                 return new VotingPhase(prevPhase, partyStates.with(action), deadline,
+                return new VotingPhase(offers, partyStates.with(action), deadline,
                                 evaluator);
+        }
 …
         @Override
         public Inform getInform() {
+                return new Voting(((OfferPhase) prevPhase).getOffers(),
+                                partyStates.getPowers());
+                return new Voting(offers, partyStates.getPowers());
+        }
         @Override
         public VotingPhase with(ProtocolException e) {
                 return new VotingPhase(prevPhase, partyStates.with(e), deadline,
+                return new VotingPhase(offers, partyStates.with(e), deadline,
                                 evaluator);
+        }
 …
         @Override
         public VotingPhase finish() {
                 return new VotingPhase(prevPhase, partyStates.finish(), deadline,
+                return new VotingPhase(offers, partyStates.finish(), deadline,
                                 evaluator);
+        }
 …
         @Override
         protected Phase checkedNext(long deadln) {
+                return new OptInPhase(this, partyStates.flush(), deadln, evaluator);
+                return new OptInPhase(getVotes(), partyStates.flush(), deadln,
+                                evaluator);
+        }
 …
+        }
+        /**
+         * @return all votes done in this phase.
+         */
+        public List<Votes> getVotes() {
+                return partyStates.getActions().stream()
+                                .filter(act -> act instanceof Votes).map(act -> (Votes) act)
+                                .collect(Collectors.toList());
+        }
+}

protocol/src/main/java/geniusweb/protocol/session/saop/SAOP.java

-              r21
+              r24
 /**
+ *
+ * All parties are first sent the {@link SessionSettings}. Only parties
+ * specified initially in the settings do participate.
+ * The protocol runs as follows
  * <ol>
  * The protocol tries to start all parties. If not all parties start, the
+ * <li>The protocol tries to start all parties. If not all parties start, the
  * parties are freed up and another attempt is done to start all parties some
  * time later.
+ * <li>All parties are sent the {@link SessionSettings}. Only parties specified
+ * initially in the settings do participate.
  * <li>The session deadline clock now starts ticking.
  * <li>All parties are sent their settings.
 …
  * the protocol.
  * <p>
  * Threadsafe: all entrypoints are synhronized.
+ * Thread safe: all entry points are synchronized.
  */
 public class SAOP extends DefaultListenable<ProtocolEvent>
 …
         /**
+         *
+         * @param state normally the initial state coming from SAOPSettings
+         * @param state  normally the initial state coming from SAOPSettings
+         * @param logger the Reporter to log to
          */
         public SAOP(SAOPState state, Reporter logger) {

protocol/src/main/java/geniusweb/protocol/session/saop/SAOPSettings.java

r21	r24
27	27	* protocol. But SAOP can be initialized with less, for
28	28	* use in TournamentSettings.
29		* @param deadline
	29	* @param deadline the deadline of the negotiation
30	30	*/
31	31	@JsonCreator

protocol/src/main/java/geniusweb/protocol/session/saop/SAOPState.java

-              r23
+              r24
         /**
+         *
          * @param actions
+         * @param actions       the actions done by the parties
          * @param conns         the existing party connections. we assume ownership
          *                      of this so it should not be modified although
 …
         /**
+         *
+         * @param e             the error that occured
+         * @param currentTimeMs the current time in ms since 1970, see
+         *                      {@link System#currentTimeMillis()}
+         * @param e the error that occured
          * @return a new state with the error set.
          */
 …
         /**
+         * @param actor         the actor that did this action. Can be used to check
+         *                      if action is valid. NOTICE caller has to make sure
+         *                      the current state is not final.
+         * @param action        the action that was proposed by actor.
+         * @param currentTimeMs the current time in ms since 1970, see
+         *                      {@link System#currentTimeMillis()}
+         * @return new SessionState with the action added as last action.
+         * @param actor  the actor that did this action. Can be used to check if
+         *               action is valid. NOTICE caller has to make sure the current
+         *               state is not final.
+         * @param action the action that was proposed by actor.
+         * @return new SAOPState with the action added as last action.
          */

protocol/src/main/java/geniusweb/protocol/session/shaop/BareSHAOPState.java

-              r23
+              r24
         /**
+         *
          * @param actions    value for actions done so far. null equals to empty
          *                   list
          * @param conns      the currently existing connections. Can be empty/null.
          *                   Each connection represents another party. Normally the
          *                   connections are in the order SHAOP1,COB1,SHAOP2,COB2,..
          *                   so 2 parties for each team. The protocol should check
          *                   this.
          * @param progr      the {@link Progress} that governs this session. Can be
          *                   null if session did not yet start.
          * @param settings   the settings used for the session
          * @param e          the exception that occured, usually null. All errors
          *                   occuring due to faulty {@link Action}s translate to
          *                   {@link ProtocolException}s. All errors in our own code
          *                   are bugs (not ProtocolExceptions) and should result in
          *                   a throw.
          * @param teamNr     the teamnr (0,1,2..) that has the turn. 2* gives index
          *                   {@link #connections} and settings
          * @param partyNrs   a map for each known PartyId to a number. The number is
          *                   the index in both {@link SHAOPSettings#getTeams()} and
          *                   in {@link #connections}. null is empyt map.
          * @param totalSpent total accumulated elicitation costs so far. only SHAOP
          *                   parties accumulate costs. null = empty map
+         * @param actions  value for actions done so far. null equals to empty list
+         * @param conns    the currently existing connections. Can be empty/null.
+         *                 Each connection represents another party. Normally the
+         *                 connections are in the order SHAOP1,COB1,SHAOP2,COB2,..
+         *                 so 2 parties for each team. The protocol should check
+         *                 this.
+         * @param progr    the {@link Progress} that governs this session. Can be
+         *                 null if session did not yet start.
+         * @param settings the settings used for the session
+         * @param e        the exception that occured, usually null. All errors
+         *                 occuring due to faulty {@link Action}s translate to
+         *                 {@link ProtocolException}s. All errors in our own code
+         *                 are bugs (not ProtocolExceptions) and should result in a
+         *                 throw.
+         * @param teamNr   the teamnr (0,1,2..) that has the turn. 2* gives index
+         *                 {@link #connections} and settings
+         * @param partyNrs a map for each known PartyId to a number. The number is
+         *                 the index in both {@link SHAOPSettings#getTeams()} and in
+         *                 {@link #connections}. null is empyt map.
+         * @param spent    total accumulated elicitation costs so far for each
+         *                 party. only SHAOP parties accumulate costs. null = empty
+         *                 map
          */
         @JsonCreator

protocol/src/main/java/geniusweb/protocol/session/shaop/SHAOP.java

-              r21
+              r24
         /**
+         *
+         * @param state normally the initial state coming from SAOPSettings
+         * @param state  normally the initial state coming from SAOPSettings
+         * @param logger the {@link Reporter} to use
          */
         public SHAOP(SHAOPState state, Reporter logger) {

protocol/src/main/java/geniusweb/protocol/session/shaop/SHAOPState.java

-              r21
+              r24
          * see {@link BareSHAOPState}.
          */
+        /**
+         *
+         * @param actions       see
+         *                      {@link BareSHAOPState#BareSHAOPState(List, ProtocolToPartyConnections, Progress, SHAOPSettings, ProtocolException, int, Map, Map)}.
+         * @param conns         see
+         *                      {@link BareSHAOPState#BareSHAOPState(List, ProtocolToPartyConnections, Progress, SHAOPSettings, ProtocolException, int, Map, Map)}.
+         * @param progress      see
+         *                      {@link BareSHAOPState#BareSHAOPState(List, ProtocolToPartyConnections, Progress, SHAOPSettings, ProtocolException, int, Map, Map)}.
+         * @param settings      see
+         *                      {@link BareSHAOPState#BareSHAOPState(List, ProtocolToPartyConnections, Progress, SHAOPSettings, ProtocolException, int, Map, Map)}.
+         * @param e             see
+         *                      {@link BareSHAOPState#BareSHAOPState(List, ProtocolToPartyConnections, Progress, SHAOPSettings, ProtocolException, int, Map, Map)}.
+         * @param teamNr        see
+         *                      {@link BareSHAOPState#BareSHAOPState(List, ProtocolToPartyConnections, Progress, SHAOPSettings, ProtocolException, int, Map, Map)}.
+         * @param partytNumbers see
+         *                      {@link BareSHAOPState#BareSHAOPState(List, ProtocolToPartyConnections, Progress, SHAOPSettings, ProtocolException, int, Map, Map)}.
+         * @param spent         see
+         *                      {@link BareSHAOPState#BareSHAOPState(List, ProtocolToPartyConnections, Progress, SHAOPSettings, ProtocolException, int, Map, Map)}.
+         */
         @JsonCreator
         public SHAOPState(@JsonProperty("actions") List<Action> actions,
 …
         /**
+         *
          * @param party
          * @return true iff party is a SHAOP party.
+         * @param party the {@link PartyId} to test
+         * @return true iff party is a SHAOP party (not a COB party).
          */
         public boolean isShaopParty(PartyId party) {
 …
         /**
+         *
          * @return the team leader {@link PartyId}s.
+         * @return the team leader {@link PartyId}s which are the SHAOP parties.
          */
         private Set<PartyId> getLeaders() {
 …
         /**
+         *
+         * @param e             the error that occured
+         * @param currentTimeMs the current time in ms since 1970, see
+         *                      {@link System#currentTimeMillis()}
+         * @param e the error that occured
          * @return a new state with the error set.
          */
 …
         /**
+         * @param actor         the actor that did this action. Can be used to check
+         *                      if action is valid. NOTICE caller has to make sure
+         *                      the current state is not final.
+         * @param action        the action that was proposed by actor.
+         * @param currentTimeMs the current time in ms since 1970, see
+         *                      {@link System#currentTimeMillis()}
+         * @param actor  the actor that did this action. Can be used to check if
+         *               action is valid. NOTICE caller has to make sure the current
+         *               state is not final.
+         * @param action the action that was proposed by actor.
          * @return new SessionState with the action added as last action.
          */

protocol/src/main/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsProtocol.java

-              r20
+              r24
         /**
+         *
          * @param state
+         * @param state  the {@link AllPermutationsState}
          * @param logger used for all logging, about the tournament, and the created
          *               the session and protocols.
 …
                         long now = System.currentTimeMillis();
                         if (sessionstate.isFinal(now)) {
-                                // List<TeamOfPartiesAndProfiles> participants =
-                                // sessionstate.getSettings().getParticipants()
                                 SessionResult result = sessionstate.getResult();
                                 state = state.with(result);

protocol/src/main/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsSettings.java

-              r21
+              r24
         /**
+         *
+         * @param teams             a list of {@link Team}s. Must contain at least
+         *                          {@link #teamsPerSession} elements. The
+         *                          <teamsize> must match the protocol: (SAOP:1,
+         *                          SHAOP:2)
+         * @param reuseTeams        if true, we use PermutationsWithReturn, if false
+         *                          we use PermutationsWithoutReturn to create the
+         *                          teams.
+         * @param plists            list of available {@link ProfileList}s to be
+         *                          permutated over the teams. Each
+         *                          {@link ProfileList} must contain <teamsize>
+         *                          elements.
+         * @param teamsPerSession   number of parties per session, must be at least
+         *                          2.
+         * @param sesettings        The generic {@link SessionSetting}.
+         *                          {@link SessionSettings#with(PartyWithProfile)}
+         *                          will be used to add the required
+         *                          {@link PartyWithProfile}s
+         * @param numberTournaments the number of times the tournament should be
+         *                          run.
+         * @param teams           a list of {@link Team}s. Must contain at least
+         *                        {@link #teamsPerSession} elements. The
+         *                        {@link #teamsPerSession} must match the protocol:
+         *                        (SAOP:1, SHAOP:2)
+         * @param reuseTeams      if true, we use PermutationsWithReturn, if false
+         *                        we use PermutationsWithoutReturn to create the
+         *                        teams.
+         * @param plists          list of available {@link ProfileList}s to be
+         *                        permutated over the teams. Each
+         *                        {@link ProfileList} must contain
+         *                        {@link #teamsPerSession} elements.
+         * @param teamsPerSession number of parties per session, must be at least 2.
+         * @param sesettings      The generic {@link SessionSettings}.
+         *                        {@link SessionSettings#with(TeamOfPartiesAndProfiles)}
+         *                        will be used to add the required
+         *                        {@link TeamOfPartiesAndProfiles}s
+         * @param nTournaments    the number of times the tournament should be run.
          */
         @JsonCreator

protocol/src/test/java/geniusweb/protocol/session/mopac/MOPACTest.java

-              r21
+              r24
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyLong;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 …
 import java.io.IOException;
 import java.util.Arrays;
+import java.util.Date;
 import java.util.List;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 …
 import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
 import geniusweb.protocol.partyconnection.ProtocolToPartyConnFactory;
+import geniusweb.protocol.session.mopac.phase.OfferPhase;
+import geniusweb.protocol.session.mopac.phase.Phase;
+import geniusweb.protocol.session.mopac.phase.VotingPhase;
 import tudelft.utilities.logging.Reporter;
 import tudelft.utilities.repository.NoResourcesNowException;
 …
                         conn3 = mock(ProtocolToPartyConn.class);
+        private List<ProtocolToPartyConn> connections;
         @Before
         public void before() throws JsonParseException, JsonMappingException,
 …
                 mopac = settings.getProtocol(logger);
                 List connections = Arrays.asList(conn1, conn2, conn3);
+                connections = Arrays.asList(conn1, conn2, conn3);
                 when(factory.connect(any(List.class))).thenReturn(connections);
 …
+        }
-        @Ignore
         @Test
         public void testWorkingCheckDeadline()
 …
                 mopac.start(factory);
+                System.out.println(mopac.getState());
+                assertFalse(mopac.getState().isFinal(System.currentTimeMillis()));
                 // we have deadline in 100ms so check
                 Thread.sleep(200);
-                System.out.println(mopac.getState());
                 assertTrue(mopac.getState().isFinal(System.currentTimeMillis()));
+        }
-        @Ignore
         @Test
         public void testSubscribedToConnections() {
 …
+        }
-        @Ignore
         @Test
         public void testActionIsBroadcast()
 …
+        }
+        @Test
+        public void testAgreementTerminates() {
+        }
+        /**
+         * Fatal error occurs, run should fail
+         */
+        @Test(expected = RuntimeException.class)
+        public void testPartyFailsConnect()
+                        throws IOException, NoResourcesNowException {
+                ProtocolToPartyConnFactory factory1 = mock(
+                                ProtocolToPartyConnFactory.class);
+                // irrecoverable fail test
+                when(factory1.connect(any(List.class)))
+                                .thenThrow(new IOException("Failed to connect to parties"));
+                mopac.start(factory1);
+        }
+        /**
+         * Nonfatal error occurs, protocol should retry till success
+         */
+        @Test
+        public void testPartyFailsConnect2ndtimeOK()
+                        throws IOException, NoResourcesNowException {
+                long now = System.currentTimeMillis();
+                ProtocolToPartyConnFactory factory1 = mock(
+                                ProtocolToPartyConnFactory.class);
+                // recoverable fail, and then success.
+                when(factory1.connect(any(List.class)))
+                                .thenThrow(new NoResourcesNowException("try again later",
+                                                new Date(now + 100)))
+                                .thenReturn(connections);
+                mopac.start(factory1);
+        }
+        /**
+         * Test that in Offer phase, and party does action, the next phase is
+         * entered.
+         */
+        @Test
+        public void testProceedsNextPhase() {
+                // the state before the last party makes the offer
+                MOPACState offerstate = mock(MOPACState.class);
+                when(offerstate.getSettings()).thenReturn(settings);
+                OfferPhase offerphase = mock(OfferPhase.class);
+                when(offerphase.isFinal(anyLong())).thenReturn(false);
+                when(offerstate.getPhase()).thenReturn(offerphase);
+                // the phase where all parties placed an offer
+                OfferPhase finalofferphase = mock(OfferPhase.class);
+                when(finalofferphase.isFinal(anyLong())).thenReturn(true);
+                MOPACState finalofferstate = mock(MOPACState.class);
+                when(finalofferstate.getPhase()).thenReturn(finalofferphase);
+                when(finalofferstate.finishPhase()).thenReturn(finalofferstate);
+                when(offerstate.with(any(PartyId.class), any(Action.class), anyLong()))
+                                .thenReturn(finalofferstate);
+                // the phase where all parties can start voting.
+                // this is the state to be reached.
+                long now = System.currentTimeMillis();
+                MOPACState votingstate = mock(MOPACState.class);
+                Phase votingphase = mock(VotingPhase.class);
+                PartyStates votingpartystates = mock(PartyStates.class);
+                when(votingphase.getDeadline()).thenReturn(now + 100);
+                when(votingphase.getPartyStates()).thenReturn(votingpartystates);
+                when(votingstate.getPhase()).thenReturn(votingphase);
+                when(finalofferstate.nextPhase(anyLong())).thenReturn(votingstate);
+                mopac = new MOPAC(offerstate, logger);
+                Offer action = mock(Offer.class);
+                mopac.actionRequest(conn3, action, now);
+                // check that the action result in reaching the voting phase
+                assertEquals(votingstate, mopac.getState());
+        }
+}

protocol/src/test/java/geniusweb/protocol/session/mopac/PartyStatesTest.java

-              r21
+              r24
 import static org.junit.Assert.assertEquals;
+import java.io.IOException;
+import java.net.URISyntaxException;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import org.junit.Test;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import geniusweb.actions.PartyId;
 import geniusweb.inform.Agreements;
 import geniusweb.protocol.ProtocolException;
+import tudelft.utilities.junit.GeneralTests;
+public class PartyStatesTest {
+public class PartyStatesTest extends GeneralTests<PartyStates> {
+        private final ObjectMapper jackson = new ObjectMapper();
         private final PartyId party1 = new PartyId("party1");
 …
         private final Map<PartyId, Integer> powers = new HashMap<>();
+        private final PartyStates states;
+        private final PartyStates states1, states1a, states2;
+        private final String serialized = "{\"notYetActed\":[\"party2\",\"party1\",\"party3\"],\"actions\":[],\"agreements\":{},\"walkedAway\":[],\"exceptions\":{},\"powers\":{\"party2\":3,\"party1\":2,\"party3\":3}}";
         public PartyStatesTest() {
+                // FIXME use the other constructor to really test this.
+//              PartyStates(Set<PartyId> notYetActed, List<Action> actions,
+//                              Agreements agreements, List<PartyId> walkedAway,
+//                              Map<PartyId, ProtocolException> exceptions,
+//                              Map<PartyId, Integer> powers)
+//
                 powers.put(party1, 2);
                 powers.put(party2, 3);
+                states2 = new PartyStates(powers);
                 powers.put(party3, 3);
+                states = new PartyStates(powers);
+                states1 = new PartyStates(powers);
+                states1a = new PartyStates(powers);
+        }
+        @Override
+        public List<List<PartyStates>> getGeneralTestData() {
+                return Arrays.asList(Arrays.asList(states1, states1a),
+                                Arrays.asList(states2));
+        }
+        @Override
+        public List<String> getGeneralTestStrings() {
+                return Arrays.asList(
+                                "PartyStates.*\\[party2, party1, party3\\],\\[\\],Agreements\\{\\},\\[\\],\\{\\}.*",
+                                "PartyStates.*\\[party2, party1\\],\\[\\],Agreements\\{\\},\\[\\],\\{\\}.*");
+        }
         @Test
         public void testBasics() {
                 assertEquals(powers.keySet(), states.getNegotiatingParties());
                 assertEquals(powers.keySet(), states.getNotYetActed());
                 assertEquals(0, states.getExceptions().size());
+                assertEquals(powers.keySet(), states1.getNegotiatingParties());
+                assertEquals(powers.keySet(), states1.getNotYetActed());
+                assertEquals(0, states1.getExceptions().size());
+        }
         @Test
         public void testException() {
                 PartyStates newstates = states
+                PartyStates newstates = states1
                                 .with(new ProtocolException("bla", party1));
                 assertEquals(new Agreements(), newstates.getAgreements());
                 assertEquals(powers.keySet(), states.getNegotiatingParties());
+                assertEquals(powers.keySet(), states1.getNegotiatingParties());
                 assertEquals(new HashSet<>(Arrays.asList(party2, party3)),
                                 newstates.getNotYetActed());
 …
         @Test
         public void testFinish() {
                 PartyStates newstates = states.finish();
+                PartyStates newstates = states1.finish();
                 assertEquals(new Agreements(), newstates.getAgreements());
                 assertEquals(powers.keySet(), states.getNegotiatingParties());
+                assertEquals(powers.keySet(), states1.getNegotiatingParties());
                 assertEquals(Collections.emptySet(), newstates.getNotYetActed());
+        }
+        @Test
+        public void testDeserialize() throws IOException {
+                PartyStates obj = jackson.readValue(serialized, PartyStates.class);
+                System.out.println(obj);
+                assertEquals(states1, obj);
+        }
+        @Test
+        public void testSerialize()
+                        throws JsonProcessingException, URISyntaxException {
+                String string = jackson.writeValueAsString(states1);
+                System.out.println(string);
+                assertEquals(serialized, string);
+        }
+        @Test
+        public void testWalkAway() {
+                PartyStates walkawaystate = states1.withWalkAway(party2);
+                assertEquals(new HashSet<>(Arrays.asList(party1, party3)),
+                                walkawaystate.getNotYetActed());
+                assertEquals(Arrays.asList(party2), walkawaystate.getWalkedAway());
+        }
+}

protocol/src/test/java/geniusweb/protocol/session/mopac/phase/OfferPhaseTest.java

-              r21
+              r24
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import org.junit.Test;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import geniusweb.actions.Accept;
 import geniusweb.actions.EndNegotiation;
+import geniusweb.actions.Offer;
 import geniusweb.actions.PartyId;
 import geniusweb.actions.Votes;
+import geniusweb.inform.YourTurn;
+import geniusweb.issuevalue.Bid;
+import geniusweb.issuevalue.DiscreteValue;
 import geniusweb.protocol.ProtocolException;
 import geniusweb.protocol.session.mopac.PartyStates;
 import geniusweb.voting.VotingEvaluator;
+import geniusweb.voting.votingevaluators.LargestAgreement;
+import geniusweb.voting.votingevaluators.LargestAgreementsLoop;
+import tudelft.utilities.junit.GeneralTests;
 /**
  * We also test defaultPhase here.
  */
+public class OfferPhaseTest {
+public class OfferPhaseTest extends GeneralTests<OfferPhase> {
+        private final ObjectMapper jackson = new ObjectMapper();
+        private static final long DEADLINE = 10l;
         private final PartyId party1 = new PartyId("party1");
         private final PartyId party2 = new PartyId("party2");
 …
         private final Map<PartyId, Integer> powers = new HashMap<>();
+        private final PartyStates states;
+        private final VotingEvaluator evaluator = mock(VotingEvaluator.class);
+        private final OfferPhase phase;
+        private final PartyStates states, states2;
+        private final VotingEvaluator evaluator = new LargestAgreement();
+        private final VotingEvaluator evaluator2 = new LargestAgreementsLoop();
+        private final OfferPhase phase, phase1, phase1a, phase2, phase3, phase4;
+        // just a test bid
+        private final Bid bid = new Bid("issue", new DiscreteValue("yes"));
+        private final Offer offer = new Offer(party1, bid);
+        private final String serialized = "{\"OfferPhase\":{\"partyStates\":{\"notYetActed\":[\"party2\",\"party1\",\"party3\"],\"actions\":[],\"agreements\":{},\"walkedAway\":[],\"exceptions\":{},\"powers\":{\"party2\":3,\"party1\":2,\"party3\":3}},\"evaluator\":{\"LargestAgreement\":{}},\"deadline\":10}}";
         public OfferPhaseTest() {
                 powers.put(party1, 2);
                 powers.put(party2, 3);
+                states2 = new PartyStates(powers);
                 powers.put(party3, 3);
                 states = new PartyStates(powers);
+                phase = new OfferPhase(null, states, 10l, evaluator);
+        }
+        @Test
+        public void isInitFinalTest() {
+                phase = new OfferPhase(states, DEADLINE, evaluator);
+                phase1 = new OfferPhase(states, 10l, evaluator);
+                phase1a = new OfferPhase(states, 10l, evaluator);
+                phase2 = new OfferPhase(states2, 10l, evaluator);
+                phase3 = new OfferPhase(states, 20l, evaluator);
+                phase4 = new OfferPhase(states, 10l, evaluator2);
+        }
+        @Override
+        public List<List<OfferPhase>> getGeneralTestData() {
+                return Arrays.asList(Arrays.asList(phase1, phase1a),
+                                Arrays.asList(phase2), Arrays.asList(phase3),
+                                Arrays.asList(phase4));
+        }
+        @Override
+        public List<String> getGeneralTestStrings() {
+                return Arrays.asList(
+                                "OfferPhase.*PartyStates.*party2, party1, party3.*\\[\\],Agreements.*\\[\\],\\{\\}.*],10,LargestAgreement.*",
+                                "OfferPhase.*PartyStates.*party2, party1.*\\[\\],Agreements.*\\[\\],\\{\\}.*],10,LargestAgreement.*",
+                                "OfferPhase.*PartyStates.*party2, party1, party3.*\\[\\],Agreements.*\\[\\],\\{\\}.*],20,LargestAgreement.*",
+                                "OfferPhase.*PartyStates.*party2, party1, party3.*\\[\\],Agreements.*\\[\\],\\{\\}.*],10,LargestAgreementsLoop.*");
+        }
+        @Test
+        public void smokeTest() {
+        }
+        @Test
+        public void testInitState() {
+                assertEquals(3, phase.getPartyStates().getNotYetActed().size());
+        }
+        @Test
+        public void testInform() {
+                assertEquals(new YourTurn(), phase.getInform());
+        }
+        @Test
+        public void isFinalTest() {
                 assertFalse(phase.isFinal(1l));
                 assertTrue(phase.isFinal(10l));
+        }
+        @Test
+        public void isFinalTestActorNotYetActed() {
+                PartyStates actedstate = mock(PartyStates.class);
+                when(actedstate.getNotYetActed())
+                                .thenReturn(Collections.singleton(party1));
+                OfferPhase testphase = new OfferPhase(actedstate, 10l, evaluator);
+                assertFalse(testphase.isFinal(1l));
+        }
+        @Test
+        public void isFinalTestAllActorsActed() {
+                PartyStates actedstate = mock(PartyStates.class);
+                when(actedstate.getNotYetActed()).thenReturn(Collections.emptySet());
+                OfferPhase testphase = new OfferPhase(actedstate, 10l, evaluator);
+                assertTrue(testphase.isFinal(1l));
+        }
 …
+        }
+        @Test
+        public void testFinish() {
+                Phase ph = phase.finish();
+                assertTrue(ph.getPartyStates().getNotYetActed().isEmpty());
+                assertEquals(3, ph.getPartyStates().getExceptions().size());
+                assertTrue(phase.getPartyStates().getAgreements().getMap().isEmpty());
+        }
+        @Test(expected = IllegalStateException.class)
+        public void testNextWrong() {
+                // state is not final, should not work
+                phase.next(1, 1000);
+        }
+        @Test
+        public void testNextNoParties() {
+                Phase ph = phase.finish();
+                // no parties are left now, all failed
+                // but this is not part of the next() check.
+                Phase next = ph.next(1, 1000);
+                assertTrue(next instanceof VotingPhase);
+                // no remaining parties, since finish kicked all
+                assertTrue(next.getPartyStates().getNotYetActed().isEmpty());
+        }
+        @Test
+        public void testAllowed() {
+                phase.with(party1, offer, 1);
+        }
+        @Test
+        public void testAllowedWrongClass() {
+                try {
+                        phase.checkAction(party1, new Accept(party1, bid), 1);
+                } catch (ProtocolException e) {
+                        assertTrue(e.getMessage().contains("not allowed in OfferPhase"));
+                        return;
+                }
+                fail("checkAction did not throw as expected");
+        }
+        @Test
+        public void testAllowedWrongActor() {
+                try {
+                        phase.checkAction(party1, new Accept(party2, bid), 1);
+                } catch (ProtocolException e) {
+                        assertTrue(
+                                        e.getMessage().contains("Incorrect actor info in action"));
+                        return;
+                }
+                fail("checkAction did not throw as expected");
+        }
+        @Test
+        public void testAllowedActorAlreadyActed() {
+                OfferPhase testphase = phase.with(party1, offer, 1);
+                try {
+                        testphase.checkAction(party1, offer, 2);
+                } catch (ProtocolException e) {
+                        assertTrue(e.getMessage().contains("can not act anymore"));
+                        return;
+                }
+                fail("checkAction did not throw as expected");
+        }
+        @Test
+        public void testAllowedActorAlreadyActed1() {
+                // as theoprevious test, but using with() instead of checkAction
+                OfferPhase testphase = phase.with(party1, offer, 1);
+                OfferPhase newphase = testphase.with(party1, offer, 2);
+                // the party must remain as acted, because we can't retract his
+                // action...
+                assertEquals(1, newphase.getPartyStates().getActions().size());
+                assertEquals(offer, newphase.getPartyStates().getActions().get(0));
+                assertFalse(
+                                newphase.getPartyStates().getExceptions().containsKey(party1));
+        }
+        @Test
+        public void testAllowedActingTooLate() {
+                try {
+                        phase.checkAction(party1, offer, DEADLINE + 1);
+                } catch (ProtocolException e) {
+                        assertTrue(e.getMessage().contains("passed deadline"));
+                        return;
+                }
+                fail("checkAction did not throw as expected");
+        }
+        @Test
+        public void getOffersTest() {
+                assertEquals(Collections.emptyList(), phase.getOffers());
+                List<Bid> offs = phase.with(party1, offer, 1).getOffers();
+                assertEquals(Arrays.asList(bid), offs);
+        }
+        @Test(expected = IllegalArgumentException.class)
+        public void testNextTooShortDuration() {
+                phase.next(1, Phase.PHASE_MINTIME - 1);
+        }
+        @Test(expected = IllegalStateException.class)
+        public void testNextNotFinished() {
+                phase.next(1, Phase.PHASE_MINTIME + 1);
+        }
+        @Test(expected = IllegalStateException.class)
+        public void testNext() {
+                phase.next(11, Phase.PHASE_MINTIME + 1);
+        }
+        @Test
+        public void testDeserialize() throws IOException {
+                Phase obj = jackson.readValue(serialized, Phase.class);
+                System.out.println(obj);
+                assertEquals(phase1, obj);
+        }
+        @Test
+        public void testSerialize()
+                        throws JsonProcessingException, URISyntaxException {
+                String string = jackson.writeValueAsString(phase1);
+                System.out.println(string);
+                assertEquals(serialized, string);
+        }
+}

protocol/src/test/java/geniusweb/protocol/session/saop/SAOPTest.java

-              r21
+              r24
 import geniusweb.events.CurrentState;
 import geniusweb.events.ProtocolEvent;
+import geniusweb.inform.Agreements;
 import geniusweb.inform.Finished;
 import geniusweb.inform.Inform;
 …
                 when(state.toString()).thenReturn(asText);
                 when(state.with(any(ProtocolException.class))).thenReturn(failstate);
+                when(state.getAgreements()).thenReturn(mock(Agreements.class));
+        }
 …
         @Test
         public void testActionRequestWrongActor() {
                 saop.actionRequest(conn2, mock(EndNegotiation.class));
 …
                 when(state.with(any(PartyId.class), any(EndNegotiation.class)))
                                 .thenReturn(finalstate);
+                // when(finalstate.getAgreements()).thenReturn(mock(Agreements.class));
                 saop.actionRequest(conn1, mock(EndNegotiation.class));
 …
                 doThrow(new IOException("fail sending yourturn")).when(conn1)
                                 .send(any(YourTurn.class));
+                // CHECK is the state really final after an exception?
+                when(state.with(any(ProtocolException.class))).thenReturn(finalstate);
+                // when(state.getAgreements()).thenReturn(mock(Agreements.class));
                 saop.actionRequest(conn1, mock(Accept.class));
 …
                 doThrow(new IOException("fail sending yourturn")).when(conn1)
                                 .send(any(YourTurn.class));
+                // when(failstate.getAgreements()).thenReturn(mock(Agreements.class));
                 // not turn of conn2.
                 saop.actionRequest(conn2, mock(EndNegotiation.class));
 …
         public void testActionInFinalState() throws IOException {
                 saop = new SAOP(finalstate, new ReportToLogger("test"));
+                // when(finalstate.getAgreements()).thenReturn(mock(Agreements.class));
                 saop.actionRequest(conn1, mock(Offer.class));

Context Navigation

Legend:

protocol/src/main/java/geniusweb/protocol/NegoProtocol.java

protocol/src/main/java/geniusweb/protocol/NegoState.java

protocol/src/main/java/geniusweb/protocol/ProtocolException.java

protocol/src/main/java/geniusweb/protocol/partyconnection/ProtocolToPartyConnections.java

protocol/src/main/java/geniusweb/protocol/session/SessionResult.java

protocol/src/main/java/geniusweb/protocol/session/SessionState.java

protocol/src/main/java/geniusweb/protocol/session/amop/AMOP.java

protocol/src/main/java/geniusweb/protocol/session/amop/AMOPSettings.java

protocol/src/main/java/geniusweb/protocol/session/amop/AMOPState.java

protocol/src/main/java/geniusweb/protocol/session/mopac/MOPAC.java

protocol/src/main/java/geniusweb/protocol/session/mopac/MOPACSettings.java

protocol/src/main/java/geniusweb/protocol/session/mopac/MOPACState.java

protocol/src/main/java/geniusweb/protocol/session/mopac/PartyStates.java

protocol/src/main/java/geniusweb/protocol/session/mopac/phase/DefaultPhase.java

protocol/src/main/java/geniusweb/protocol/session/mopac/phase/OfferPhase.java

protocol/src/main/java/geniusweb/protocol/session/mopac/phase/OptInPhase.java

protocol/src/main/java/geniusweb/protocol/session/mopac/phase/Phase.java

protocol/src/main/java/geniusweb/protocol/session/mopac/phase/VotingPhase.java

protocol/src/main/java/geniusweb/protocol/session/saop/SAOP.java

protocol/src/main/java/geniusweb/protocol/session/saop/SAOPSettings.java

protocol/src/main/java/geniusweb/protocol/session/saop/SAOPState.java

protocol/src/main/java/geniusweb/protocol/session/shaop/BareSHAOPState.java

protocol/src/main/java/geniusweb/protocol/session/shaop/SHAOP.java

protocol/src/main/java/geniusweb/protocol/session/shaop/SHAOPState.java

protocol/src/main/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsProtocol.java

protocol/src/main/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsSettings.java

protocol/src/test/java/geniusweb/protocol/session/mopac/MOPACTest.java

protocol/src/test/java/geniusweb/protocol/session/mopac/PartyStatesTest.java

protocol/src/test/java/geniusweb/protocol/session/mopac/phase/OfferPhaseTest.java

protocol/src/test/java/geniusweb/protocol/session/saop/SAOPTest.java

Download in other formats: