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: -include_lib("common_test/include/ct.hrl").
  
  -include_lib("ssh/src/ssh.hrl").
  -include_lib("ssh/src/ssh_connect.hrl").
  
  suite() -> [{ct_hooks,[{ts_install_cth,[{nodenames,2}]}]}].
  %%suite() -> [{ct_hooks,[ts_install_cth]}].
  
negative.code:     
  %%%================================================================
  find_times(L) ->
      Xs =  [accept_to_hello, kex, kex_to_auth, auth, to_prompt],
      [find_time(X,L) || X <- Xs]	++
  	crypto_algs_times_sizes([encrypt,decrypt], L).
  
  -record(call, {
  	  mfa,
  	  pid,
  	  t_call,
  	  t_return,
  	  args,
  	  result
  	 }).
  
  %%%----------------
  -define(send(M), fun(C=#call{mfa = {ssh_message,encode,1},
  			     args = [M]}) ->
  			 C#call.t_return
  		 end).
  
  -define(recv(M), fun(C=#call{mfa = {ssh_message,decode,1},
  			     result = M}) ->
  			    C#call.t_call
  		 end).
  
  find_time(accept_to_hello, L) ->
      [T0,T1] = find([fun(C=#call{mfa = {ssh_acceptor,handle_connection,5}}) ->
  			    C#call.t_call
  		    end,
  		    fun(C=#call{mfa = {ssh_connection_handler,hello,_},
  				args = [socket_control|_]}) ->
  			    C#call.t_return
  		    end
  		   ], L, []),
      {accept_to_hello, now2micro_sec(now_diff(T1,T0)), microsec};
  find_time(kex, L) ->
      [T0,T1] = find([fun(C=#call{mfa = {ssh_connection_handler,hello,_},
  				args = [socket_control|_]}) ->
  			    C#call.t_call
  		    end,
  		    ?send(#ssh_msg_newkeys{})
  		    ], L, []),
      {kex, now2micro_sec(now_diff(T1,T0)), microsec};
  find_time(kex_to_auth, L) ->
      [T0,T1] = find([?send(#ssh_msg_newkeys{}),
  		    ?recv(#ssh_msg_userauth_request{})
  		   ], L, []),
      {kex_to_auth, now2micro_sec(now_diff(T1,T0)), microsec};
  find_time(auth, L) ->
      [T0,T1] = find([?recv(#ssh_msg_userauth_request{}),
  		    ?send(#ssh_msg_userauth_success{})
  		   ], L, []),
      {auth, now2micro_sec(now_diff(T1,T0)), microsec};
  find_time(to_prompt, L) ->
      [T0,T1] = find([fun(C=#call{mfa = {ssh_acceptor,handle_connection,5}}) ->
  			    C#call.t_call
  		    end,
  		    ?recv(#ssh_msg_channel_request{request_type="env"})
  		   ], L, []),
      {to_prompt, now2micro_sec(now_diff(T1,T0)), microsec}.
  
  
  find([F|Fs], [C|Cs], Acc) when is_function(F,1) ->
      try
  	F(C)
      of
  	T -> find(Fs, Cs, [T|Acc])
      catch
  	_:_ -> find([F|Fs], Cs, Acc)
      end;
  find([], _, Acc) ->
      lists:reverse(Acc).
  
  
  find_algs(L) ->
      {value,#call{result={ok,Algs}}} =
  	lists:keysearch({ssh_transport,select_algorithm,3}, #call.mfa, L),
      Algs.
  
  %%%----------------
  crypto_algs_times_sizes(EncDecs, L) ->
      Raw = [{_Algorithm = case EncDec of
  			     encrypt -> [encrypt," ",S#ssh.encrypt];
  			     decrypt -> [decrypt," ",S#ssh.decrypt]
  			 end, 
  	    size(Data),
  	    now2micro_sec(now_diff(T1, T0))
  	   }
  	   || EncDec <- EncDecs,
  	      #call{mfa = {ssh_transport,ED,2},
  		    args = [S,Data],
  		    t_call = T0,
  		    t_return = T1} <- L,
  	      ED == EncDec
  	  ],
      [{Alg, round(1024*Time/Size), "microsec/kbyte"}  % Microseconds per 1k bytes.
       || {Alg,Size,Time} <- lists:foldl(fun increment/2, [], Raw)].
  
  increment({Alg,Sz,T}, [{Alg,SumSz,SumT}|Acc]) ->
      [{Alg,SumSz+Sz,SumT+T} | Acc];
  increment(Spec, [X|Acc]) ->
      [X | increment(Spec,Acc)]; % Not so many Alg, 2 or 3
  increment({Alg,Sz,T},[]) ->
      [{Alg,Sz,T}].
  
  %%%----------------------------------------------------------------
  %%%
  