anchor.diff:  			     Parent ! {self(),os:cmd(Cmd)}
   		     end),
       receive
  -	{SlavePid, ClientResponse} ->
  -%%	    ct:pal("ClientResponse = ~p",[ClientResponse]),
  +	{SlavePid, _ClientResponse} ->
  +%%	    ct:pal("ClientResponse = ~p",[_ClientResponse]),
   	    {ok, List} = get_trace_list(TracerPid),
   	    Times = find_times(List),
  -	    Algs = proplists:get_value(algorithms, List, #alg{}),
  -	    ct:pal("List = ~p~n~nAlgorithms = ~p~n~nTimes = ~p",[List,Algs,Times]),
  +	    Algs = find_algs(List),
  +	    ct:pal("Algorithms = ~p~n~nTimes = ~p",[Algs,Times]),
   	    lists:foreach(
  -	      fun({Tag0,MicroSeconds,Unit}) ->
  +	      fun({Tag0,Value,Unit}) ->
   		      Tag = case Tag0 of
   				{A,B} -> lists:concat([A," ",B]);
   				_ when is_list(Tag0) -> lists:concat(Tag0);
  
positive.code: 
  trace_loop(L) ->
      receive
  	{trace_ts, Pid, call, {M,F,Args}, TS} = Ev -> 
  	    cond_pal(Ev),
  	    trace_loop(save_event(call, Pid, {M,F,Args}, TS, L));
  	{trace_ts, Pid, return_from, {M,F,Arity}, Ret, TS} = Ev -> 
  	    cond_pal(Ev),
  	    trace_loop(save_event(return_from, Pid, {M,F,Arity,Ret}, TS, L));
  	{get_trace_list, From} ->
  	    From ! {trace_list, L},
  	    trace_loop(L)
  
  	; Other -> io:format('~p got ~p~n',[self(),Other]), trace_loop(L)
      end.
  	    
  %%cond_pal(Ev) -> ct:pal("~p",[Ev]).
  cond_pal(Ev) -> ok.
      
  
  save_event(_Type, _Pid, MFA, TimeStamp, L) ->
      try	
  	event_name(MFA)
      of
  	{Tag, 'TS'} -> [{Tag,TimeStamp} | L];
  	Val -> [Val | L]
      catch
  	_:_ -> L
      end.
  
  event_name({ssh_acceptor,handle_connection,_}) ->                      {tcp_accept, 'TS'};
  event_name({ssh_connection_handler,hello,[socket_control|_]}) ->       {{send,hello}, 'TS'};
  event_name({ssh_connection_handler,hello,[{version_exchange,_}|_]}) -> {{recv,hello}, 'TS'};
  event_name({ssh_message,encode,[Msg]}) ->                              {{send,element(1,Msg)}, 'TS'};
  event_name({ssh_message,decode,1,
  	    #ssh_msg_channel_request{request_type=ReqType}}) ->  {{recv,{ssh_msg_channel_request,ReqType}}, 'TS'};
  event_name({ssh_message,decode,1,Return}) ->                     {{recv,element(1,Return)}, 'TS'};
  event_name({ssh_transport,select_algorithm,3,{ok,Algs}}) ->      {algorithms,Algs};
  event_name({ssh_transport,encrypt,[S,Data]}) ->   {{{encrypt,S#ssh.encrypt},start, {S#ssh.send_sequence,size(Data)}}, 'TS'};
  event_name({ssh_transport,encrypt,2,{S,Ret}}) ->  {{{encrypt,S#ssh.encrypt},stop,  {S#ssh.send_sequence,size(Ret) }}, 'TS'};
  event_name({ssh_transport,decrypt,[S,Data]}) ->   {{{decrypt,S#ssh.decrypt},start, {S#ssh.recv_sequence,size(Data)}}, 'TS'};
  event_name({ssh_transport,decrypt,2,{S,Ret}}) ->  {{{decrypt,S#ssh.decrypt},stop,  {S#ssh.recv_sequence,size(Ret) }}, 'TS'}.
  
  
  now2sec({A,B,C}) -> A*1000000 + B + C/1000000.
  
  now2micro_sec({A,B,C}) -> (A*1000000 + B)*1000000 + C.
  		    
  now_diff({A1,B1,C1}, {A0,B0,C0}) -> {A1-A0, B1-B0, C1-C0}.
      
  
negative.code: -include_lib("common_test/include/ct.hrl").
  
  -include_lib("ssh/src/ssh.hrl").
  -include_lib("ssh/src/ssh_transport.hrl").
  -include_lib("ssh/src/ssh_connect.hrl").
  -include_lib("ssh/src/ssh_userauth.hrl").
  
  
  suite() -> [{ct_hooks,[{ts_install_cth,[{nodenames,2}]}]}].
  %%suite() -> [{ct_hooks,[ts_install_cth]}].
  