anchor.diff:      [];
   do_dont_drop(Config,N) ->
       %% Name of first slave node
  -    ?line NN1 = atom_to_list(?MODULE) ++ "slave_1",
  +    NN1 = atom_to_list(?MODULE) ++ "slave_1",
       %% Name of node started by heart on failure
  -    ?line NN2 = atom_to_list(?MODULE) ++ "slave_2",
  +    NN2 = atom_to_list(?MODULE) ++ "slave_2",
       %% Name of node started by heart on success
  -    ?line NN3 = atom_to_list(?MODULE) ++ "slave_3",
  -    ?line Host = hd(tl(string:tokens(atom_to_list(node()),"@"))),
  +    NN3 = atom_to_list(?MODULE) ++ "slave_3",
  +    Host = hd(tl(string:tokens(atom_to_list(node()),"@"))),
       %% The initial heart command
  -    ?line FirstCmd = erl() ++ name(NN2 ++ "@" ++ Host),
  +    FirstCmd = erl() ++ name(NN2 ++ "@" ++ Host),
       %% Separated the parameters to start_node_run for clarity...
  -    ?line Name = list_to_atom(NN1),
  -    ?line Env = [{"HEART_COMMAND", FirstCmd}],
  -    ?line Func = "start_heart_stress",
  -    ?line Arg = NN3 ++ "@" ++ Host ++ " " ++ 
  +    Name = list_to_atom(NN1),
  +    Env = [{"HEART_COMMAND", FirstCmd}],
  +    Func = "start_heart_stress",
  +    Arg = NN3 ++ "@" ++ Host ++ " " ++
   	filename:join(?config(data_dir, Config), "simple_echo"),
  -    ?line start_node_run(Name,Env,Func,Arg),
  -    ?line case wait_for_any_of(list_to_atom(NN2 ++ "@" ++ Host),
  -			       list_to_atom(NN3 ++ "@" ++ Host)) of
  -	      2 ->
  -		  ?line [ok | do_dont_drop(Config,N-1)];
  -	      _ ->
  -		  ?line false
  -	  end.
  +    start_node_run(Name,Env,Func,Arg),
  +    case wait_for_any_of(list_to_atom(NN2 ++ "@" ++ Host),
  +	    list_to_atom(NN3 ++ "@" ++ Host)) of
  +	2 ->
  +	    [ok | do_dont_drop(Config,N-1)];
  +	_ ->
  +	    false
  +    end.
   
   wait_for_any_of(N1,N2) ->
  -    ?line wait_for_any_of(N1,N2,45).
  +    wait_for_any_of(N1,N2,45).
   
   wait_for_any_of(_N1,_N2,0) ->
  -    ?line false;
  +    false;
   
   wait_for_any_of(N1,N2,Times) ->
  -    ?line receive 
  -	  after 1000 ->
  -		  ?line ok
  -	  end,
  -    ?line case net_adm:ping(N1) of
  -	      pang ->
  -		  ?line case net_adm:ping(N2) of
  -			    pang ->
  -				?line wait_for_any_of(N1,N2,Times - 1);
  -			    pong ->
  -				?line rpc:call(N2,init,stop,[]),  
  -				?line 2
  -			end;
  -	      pong ->
  -		  ?line rpc:call(N1,init,stop,[]),  
  -		  ?line 1
  -	  end.
  +    receive after 1000 -> ok end,
  +    case net_adm:ping(N1) of
  +	pang ->
  +	    case net_adm:ping(N2) of
  +		pang ->
  +		    wait_for_any_of(N1,N2,Times - 1);
  +		pong ->
  +		    rpc:call(N2,init,stop,[]),
  +		    2
  +	    end;
  +	pong ->
  +	    rpc:call(N1,init,stop,[]),
  +	    1
  +    end.
   
   
   kill_pid(suite) ->
  
positive.code: end_per_testcase(_Func, Config) ->
      Nodes = nodes(),
      lists:foreach(fun(X) ->
  			  NNam = list_to_atom(hd(string:tokens(atom_to_list(X),"@"))),
  			  case NNam of
  			      heart_test ->
  				  ?t:format(1, "WARNING: Killed ~p~n", [X]),
  				  rpc:cast(X, erlang, halt, []);
  			      _ ->
  				  ok
  			  end
  		  end, Nodes),
      Dog=?config(watchdog, Config),
      test_server:timetrap_cancel(Dog).
  
  
negative.code: 	    test_server:fail(node_not_closed)
      end,
      test_server:sleep(5000),
      case net_adm:ping(Node) of
  	pang ->
  	    ok;
  	_ ->
  	    test_server:fail(node_rebooted)
      end,
      ok.
  
  get_cmd(suite) -> [];
  get_cmd(Config) when is_list(Config) ->
      {ok, Node} = start_check(slave, heart_test),
      Cmd = "test",
      ok = rpc:call(Node, heart, set_cmd, [Cmd]),
      {ok, Cmd} = rpc:call(Node, heart, get_cmd, []),
      stop_node(Node),
      ok.
  
  