anchor.diff:          true ->
               S
       end;
  -%% all the other commands do not change the abstract state
  +% all the other commands do not change the abstract state
   next_state(S, _V, _Command) ->
       S.
   
  -%% define the conditions needed to be
  -%% met in order for a test to pass
  +% define the conditions needed to be
  +% met in order for a test to pass
   postcondition(S, {call,?MODULE,request_stream_with_size,[_Size,StreamName]}, Result) ->
       Stream = lists:keysearch(StreamName,2,S#state.streams),
       case {Stream,Result} of
  -        {{value,{StreamID,_StreamName,_Data}},{ok,<<0,ID>>}} ->
  +        {{value,{StreamID,_StreamName,_Data}},ID} ->
               StreamID =:= ID;
  -        {false,{ok,_ID}} ->
  +        {false,_ID} ->
               true;
           _ ->
               false
  
positive.code:                     false
              end;
          _ ->
              false
      end;
  postcondition(_S, _Command, _Result) ->
      true.
  
  %%-----------------------------------------------------------------------------
  
negative.code: postcondition(S, {call,?MODULE,append,[StreamID,_Data]}, Result) ->
      case lists:keymember(StreamID,1,S#state.streams) of
          true ->
              Result =:= casted;
          false ->
              Result =:= unregistered_stream
      end;
  %postcondition(S, {call,?MODULE,simple_query,[StreamID,_Start,_End]}, Result) ->
  %    case Result of
  %        {ok, <<Payload/binary>>} ->
  %            Stream = lists:keysearch(StreamID,1,S#state.streams),
  %            case Stream of
  %                {value,{_StreamID, _StreamName, Expected}} ->
  %                    Observed = payload_to_list([],Payload),
  %                    Expected_Sorted = lists:sort([X || {_,X} <- Expected]),
  %                    Observed_Sorted = lists:sort([X || {_,X} <- Observed]),
  %                    Expected_Sorted =:= Observed_Sorted;
  %                _ ->
  %                    false
  %            end;
  %        _ ->
  %            false
  %    end;
  %postcondition(S, {call,?MODULE,all_since,[StreamID,Timestamp]}, Result) ->
  %    case Result of
  %        {ok, <<Payload/binary>>} ->
  %            Stream = lists:keysearch(StreamID,1,S#state.streams),
  %            case Stream of
  %                {value,{_StreamID, _StreamName, Expected}} ->
  %                    Observed = payload_to_list([],Payload),
  %                    Expected_Sorted = lists:sort([X || {Y,X} <- Expected, Y>Timestamp]),
  %                    Observed_Sorted = lists:sort([X || {_,X} <- Observed]),
  %                    Expected_Sorted =:= Observed_Sorted;
  %                _ ->
  %                    false
  %            end;
  %        _ ->
  %            false
  %    end;
  postcondition(S, {call,?MODULE,request_stream,[_Size,StreamName]}, Result) ->
      Stream = lists:keysearch(StreamName,2,S#state.streams),
      case {Stream,Result} of
          {{value,{StreamID,_StreamName,_Data}},ID} ->
              StreamID =:= ID;
          {false,_ID} ->
              true;
          _ ->
              false
      end;
  postcondition(S, {call,?MODULE,last_entry_at,[StreamID,Timestamp]}, Result) ->
      case Result of
          {ok,<<Payload/binary>>} ->
              Stream = lists:keysearch(StreamID,1,S#state.streams),
              case Stream of
                  {value,{_StreamID, _StreamName, Data}} ->
  