anchor.diff:  	  false = is_process_alive(Parser)
       end,
       Config.%}}}F
  +
  +ake_msg(_Config) ->
  +    otr_fsm:consume(fsm1, {user, start_otr}),
  +    {to_user1, {info, {encrypted_new_dsa_fp, _, _}}} =
  +	receive X -> erlang:display(X), X end,
  +    {to_user2, {info, {encrypted_new_dsa_fp, _, _}}} =
  +	receive Y -> erlang:display(Y), Y end,
  +    otr_fsm:consume(fsm2, {user, {message, "FOOO"}}),
  +    {to_user1, {message, "FOOO"}} = receive
  +				      Z -> erlang:display(Z), Z
  +				    end,
  +    ok.
   
   pt_usr_1(Config) ->
       ct:comment("message from user while in state [plaintext]"),
  
positive.code: 
  -include("MessageTestVectors.hrl").
  
  init_per_suite(Config) -> Config.
  
  end_per_suite(Config) -> Config.
  
  all() ->
      [pt_usr_1, pt_usr_2, pt_usr_start, pt_usr_stop,
       pt_net_1, pt_net_error_1, pt_net_error_2, pt_net_data,
       cover].
  
  %F{{{ init_per_testcase/2
  
negative.code:     ok.
  
  %F{{{ internal functions
  
  setup_pair(Config) ->
      Self = self(),
      EmitUser1 = fun (X) -> Self ! {to_user1, X} end,
      EmitUser2 = fun (X) -> Self ! {to_user2, X} end,
      EmitNet = fun (X) -> net_pipe ! {self(), X} end,
      {ok, Parser1} = otr_parser_fsm:start_link(),
      {ok, Parser2} = otr_parser_fsm:start_link(),
      {ok, Fsm1} = otr_fsm:start_link([{emit_user, EmitUser1},
  				     {emit_net, EmitNet}, {dsa, ?DSAKey1}]),
      {ok, Fsm2} = otr_fsm:start_link([{emit_user, EmitUser2},
  				     {emit_net, EmitNet}, {dsa, ?DSAKey2}]),
      otr_parser_fsm:set_emit_fun(Parser1,
  				fun (X) -> otr_fsm:consume(Fsm1, {net, X}) end),
      otr_parser_fsm:set_emit_fun(Parser2,
  				fun (X) -> otr_fsm:consume(Fsm2, {net, X}) end),
      NetPipe = spawn_link(fun () ->
  				 net_pipe(Fsm1, Parser1, Fsm2, Parser2)
  			 end),
      register(net_pipe, NetPipe),
      register(fsm1, Fsm1),
      register(fsm2, Fsm2),
      Config.
  
  net_pipe(Fsm1, Parser1, Fsm2, Parser2) ->
      receive
        {Fsm1, M} -> otr_parser_fsm:consume(Parser2, M);
        {Fsm2, M} -> otr_parser_fsm:consume(Parser1, M);
        _ -> exit(kill)
      end,
      net_pipe(Fsm1, Parser1, Fsm2, Parser2).
  
  setup_fsm(Config, Opts) ->
      Self = self(),
      EmitUser = fun (X) -> Self ! {to_user, X} end,
      EmitNet = fun (X) -> Self ! {to_net, X} end,
      {ok, Parser} = otr_parser_fsm:start_link(),
      {ok, Fsm} = otr_fsm:start_link([{emit_user, EmitUser},
  				    {emit_net, EmitNet}, {dsa, ?DSAKey1}
  				    | Opts]),
      otr_parser_fsm:set_emit_fun(Parser,
  				fun (X) -> otr_fsm:consume(Fsm, {net, X}) end),
  