anchor.diff:      ok.
   
   %% @private
  -set_fault(Node, Value) ->
  -    ?PROPERTY_MODULE:command_preamble(Node, [set_fault, Node, Value]),
  -
  -    Result = rpc:call(?NAME(Node), partisan_config, set, [faulted, Value], ?TIMEOUT),
  -
  -    ?PROPERTY_MODULE:command_conclusion(Node, [set_fault, Node, Value]),
  -
  -    Result.
  -
  -%% @private
   next_id(Node) ->
       ?PROPERTY_MODULE:command_preamble(Node, [next_id, Node]),
   
       Result = rpc:call(?NAME(Node), paxoid, next_id, [?GROUP], ?TIMEOUT),
       node_debug("next_id for node: ~p yieleded: ~p", [node(), Result]),
   
  -    node_debug("sleeping 250ms...", []),
  -    timer:sleep(250),
  +    % node_debug("sleeping 250ms...", []),
  +    % timer:sleep(250),
   
       ?PROPERTY_MODULE:command_conclusion(Node, [next_id, Node]),
   
  
positive.code: node_next_state(_State, NodeState, {badrpc, _}, {call, ?MODULE, next_id, [_Node]}) ->
      %% don't advance expected counter if a badrpc is generated.
      NodeState;
  node_next_state(_State, #node_state{counter=Counter}=NodeState, _Value, {call, ?MODULE, next_id, [_Node]}) ->
      NodeState#node_state{counter=Counter+1};
  node_next_state(_State, NodeState, _Response, _Command) ->
      NodeState.
  
  %% Postconditions for node commands.
  node_postcondition(#node_state{counter=Counter}, {call, ?MODULE, max_id, []}, Results) ->
      node_debug("postcondition received ~p from max_id", [Results]),
  
      CorrectNodes = lists:filter(fun({Node, Result}) -> 
          case Result >= Counter of
              true ->
                  true;
              false ->
                  case Result of 
                      undefined ->
                          %% Crashed node.
                          false; 
                      _ ->
                          node_debug("=> node: ~p has wrong value: ~p, should be ~p", [Node, Result, Counter]),
                          false
                  end
          end
      end, Results),
  
      node_debug("=> number of correct nodes: ~p", [length(CorrectNodes)]),
      case length(CorrectNodes) >= (length(names()) / 2 + 1) of 
          true ->
              node_debug("=> majority present!", []),
              true;
  
negative.code:             node_debug("=> majority NOT present!", []),
              false
      end;
  node_postcondition(_NodeState, {call, ?MODULE, wait, [_Node]}, _Result) ->
      true;
  node_postcondition(_NodeState, {call, ?MODULE, sleep, []}, _Result) ->
      true;
  node_postcondition(_NodeState, {call, ?MODULE, next_id, [_Node]}, {badrpc,timeout}) ->
      false;
  node_postcondition(_NodeState, {call, ?MODULE, next_id, [_Node]}, {badrpc, _}) ->
      %% badrpc is fine, timeout is acceptable if no write occurred.
      true;
  