anchor.diff:  
   %% port_command/2: badarg 1st arg
   command_e_1(Config) when is_list(Config) ->
  -    ?line DataDir = ?config(data_dir, Config),
  -    ?line Program = filename:join(DataDir, "port_test"),
  +    DataDir = ?config(data_dir, Config),
  +    Program = filename:join(DataDir, "port_test"),
   
       process_flag(trap_exit, true),
  -    ?line _ = spawn_link(?MODULE, do_command_e_1, [Program]),
  -    ?line receive
  -	      {'EXIT', Pid, {badarg, _}} when is_pid(Pid) ->
  -		  ok;
  -	      Other ->
  -		  ?line test_server:fail(Other)
  -	  after 10000 ->
  -		  ?line test_server:fail(timeout)
  -	  end,
  +    _ = spawn_link(?MODULE, do_command_e_1, [Program]),
  +    receive
  +        {'EXIT', Pid, {badarg, _}} when is_pid(Pid) ->
  +            ok;
  +        Other ->
  +            test_server:fail(Other)
  +    after 10000 ->
  +            test_server:fail(timeout)
  +    end,
       ok.
   
   do_command_e_1(Program) ->
  -    ?line _ = open_port({spawn, Program}, []),
  -    ?line erlang:port_command(apple, "plock"),
  +    _ = open_port({spawn, Program}, []),
  +    erlang:port_command(apple, "plock"),
       exit(survived).
   
   %% port_command/2: badarg 2nd arg
   command_e_2(Config) when is_list(Config) ->
  -    ?line DataDir = ?config(data_dir, Config),
  -    ?line Program = filename:join(DataDir, "port_test"),
  +    DataDir = ?config(data_dir, Config),
  +    Program = filename:join(DataDir, "port_test"),
   
       process_flag(trap_exit, true),
  -    ?line _ = spawn_link(?MODULE, do_command_e_2, [Program]),
  -    ?line receive
  -	      {'EXIT', Pid, {badarg, _}} when is_pid(Pid) ->
  -		  ok;
  -	      Other ->
  -		  ?line test_server:fail(Other)
  -	  after 10000 ->
  -		  ?line test_server:fail(timeout)
  -	  end,
  +    _ = spawn_link(?MODULE, do_command_e_2, [Program]),
  +    receive
  +        {'EXIT', Pid, {badarg, _}} when is_pid(Pid) ->
  +            ok;
  +        Other ->
  +            test_server:fail(Other)
  +    after 10000 ->
  +            test_server:fail(timeout)
  +    end,
       ok.
   
   do_command_e_2(Program) ->
  -    ?line P = open_port({spawn, Program}, []),
  -    ?line erlang:port_command(P, 1),
  +    P = open_port({spawn, Program}, []),
  +    erlang:port_command(P, 1),
       exit(survived).
   
   %% port_command/2: Posix signals trapped
   command_e_3(Config) when is_list(Config) ->
  -    ?line DataDir = ?config(data_dir, Config),
  -    ?line Program = filename:join(DataDir, "port_test"),
  +    DataDir = ?config(data_dir, Config),
  +    Program = filename:join(DataDir, "port_test"),
   
       process_flag(trap_exit, true),
  -    ?line P = open_port({spawn, Program}, [{packet, 1}]),
  -    ?line Data = lists:duplicate(257, $a),
  -    ?line erlang:port_command(P, Data),
  -    ?line receive
  -	      {'EXIT', Port, einval} when is_port(Port) ->
  -		  ok;
  -	      Other ->
  -		  test_server:fail(Other)
  -	  after 10000 ->
  -		  test_server:fail(timeout)
  -	  end,
  +    P = open_port({spawn, Program}, [{packet, 1}]),
  +    Data = lists:duplicate(257, $a),
  +    erlang:port_command(P, Data),
  +    receive
  +        {'EXIT', Port, einval} when is_port(Port) ->
  +            ok;
  +        Other ->
  +            test_server:fail(Other)
  +    after 10000 ->
  +            test_server:fail(timeout)
  +    end,
       ok.
   
   %% port_command/2: Posix exit signals not trapped
   command_e_4(Config) when is_list(Config) ->
  -    ?line DataDir = ?config(data_dir, Config),
  -    ?line Program = filename:join(DataDir, "port_test"),
  +    DataDir = ?config(data_dir, Config),
  +    Program = filename:join(DataDir, "port_test"),
   
       process_flag(trap_exit, true),
  -    ?line _ = spawn_link(?MODULE, do_command_e_4, [Program]),
  -    ?line receive
  -	      {'EXIT', Pid, {einval, _}} when is_pid(Pid) ->
  -		  ok;
  -	      Other ->
  -		  ?line test_server:fail(Other)
  -	  after 10000 ->
  -		  ?line test_server:fail(timeout)
  -	  end,
  +    _ = spawn_link(?MODULE, do_command_e_4, [Program]),
  +    receive
  +        {'EXIT', Pid, {einval, _}} when is_pid(Pid) ->
  +            ok;
  +        Other ->
  +            test_server:fail(Other)
  +    after 10000 ->
  +            test_server:fail(timeout)
  +    end,
       ok.
   
   do_command_e_4(Program) ->
  -    ?line P = open_port({spawn, Program}, [{packet, 1}]),
  -    ?line Data = lists:duplicate(257, $a),
  -    ?line erlang:port_command(P, Data),
  +    P = open_port({spawn, Program}, [{packet, 1}]),
  +    Data = lists:duplicate(257, $a),
  +    erlang:port_command(P, Data),
       exit(survived).
   
   
   %% Tests the port_info/1 BIF
   port_info1(Config) when is_list(Config) ->
  -    ?line load_control_drv(Config),
  +    load_control_drv(Config),
       Me=self(),
  -    ?line P = open_port({spawn, control_drv}, []),
  -    ?line A1 = erlang:port_info(P),
  -    ?line false = lists:keysearch(registered_name, 1, A1),
  -    ?line register(myport, P),
  -    ?line A = erlang:port_info(P),
  -    ?line {value,{registered_name,myport}}=
  -	lists:keysearch(registered_name, 1, A),
  -    ?line {value,{name,"control_drv"}}=lists:keysearch(name, 1, A),
  -    ?line {value,{links,[Me]}}=lists:keysearch(links, 1, A),
  -    ?line {value,{id,_IdNum}}=lists:keysearch(id, 1, A),
  -    ?line {value,{connected,_}}=lists:keysearch(connected, 1, A),
  -    ?line {value,{input,0}}=lists:keysearch(input, 1, A),
  -    ?line {value,{output,0}}=lists:keysearch(output, 1, A),
  -    ?line {value,{os_pid,undefined}}=lists:keysearch(os_pid, 1, A),  % linked-in driver doesn't have a OS pid
  -    ?line true=erlang:port_close(P),
  +    P = open_port({spawn, control_drv}, []),
  +    A1 = erlang:port_info(P),
  +    false = lists:keysearch(registered_name, 1, A1),
  +    register(myport, P),
  +    A = erlang:port_info(P),
  +    {value,{registered_name,myport}}= lists:keysearch(registered_name, 1, A),
  +    {value,{name,"control_drv"}}=lists:keysearch(name, 1, A),
  +    {value,{links,[Me]}}=lists:keysearch(links, 1, A),
  +    {value,{id,_IdNum}}=lists:keysearch(id, 1, A),
  +    {value,{connected,_}}=lists:keysearch(connected, 1, A),
  +    {value,{input,0}}=lists:keysearch(input, 1, A),
  +    {value,{output,0}}=lists:keysearch(output, 1, A),
  +    {value,{os_pid,undefined}}=lists:keysearch(os_pid, 1, A),  % linked-in driver doesn't have a OS pid
  +    true=erlang:port_close(P),
       ok.
   
   %% Tests erlang:port_info/2"
   port_info2(Config) when is_list(Config) ->
  -    ?line load_control_drv(Config),
  -
  -    ?line P = open_port({spawn,control_drv}, [binary]),
  -    ?line [] = erlang:port_info(P, registered_name),
  -    ?line register(myport, P),
  -    ?line {registered_name, myport} = erlang:port_info(P, registered_name),
  -
  -    ?line {name, "control_drv"}=erlang:port_info(P, name),
  -    ?line {id, _IdNum} = erlang:port_info(P, id),
  +    load_control_drv(Config),
  +
  +    P = open_port({spawn,control_drv}, [binary]),
  +    [] = erlang:port_info(P, registered_name),
  +    register(myport, P),
  +    {registered_name, myport} = erlang:port_info(P, registered_name),
  +
  +    {name, "control_drv"}=erlang:port_info(P, name),
  +    {id, _IdNum} = erlang:port_info(P, id),
       Me=self(),
  -    ?line {links, [Me]} = erlang:port_info(P, links),
  -    ?line {connected, Me} = erlang:port_info(P, connected),
  -    ?line {input, 0}=erlang:port_info(P, input),
  -    ?line {output,0}=erlang:port_info(P, output),
  -    ?line {os_pid, undefined}=erlang:port_info(P, os_pid),  % linked-in driver doesn't have a OS pid
  -
  -    ?line erlang:port_control(P, $i, "abc"),
  -    ?line receive
  -	      {P,{data,<<"abc">>}} -> ok
  -	  end,
  -    ?line {input,3} = erlang:port_info(P, input),
  -    ?line {output,0} = erlang:port_info(P, output),
  -
  -    ?line Bin = list_to_binary(lists:duplicate(2047, 42)),
  -    ?line output_test(P, Bin, 3, 0),
  +    {links, [Me]} = erlang:port_info(P, links),
  +    {connected, Me} = erlang:port_info(P, connected),
  +    {input, 0}=erlang:port_info(P, input),
  +    {output,0}=erlang:port_info(P, output),
  +    {os_pid, undefined}=erlang:port_info(P, os_pid),  % linked-in driver doesn't have a OS pid
  +
  +    erlang:port_control(P, $i, "abc"),
  +    receive
  +        {P,{data,<<"abc">>}} -> ok
  +    end,
  +    {input,3} = erlang:port_info(P, input),
  +    {output,0} = erlang:port_info(P, output),
  +
  +    Bin = list_to_binary(lists:duplicate(2047, 42)),
  +    output_test(P, Bin, 3, 0),
       
  -    ?line true = erlang:port_close(P),
  +    true = erlang:port_close(P),
       ok.
   
   %% Tests the port_info/1,2 os_pid option BIF
  
positive.code:     <<Op:32>> = list_to_binary(R).
  
  echo_to_busy(Config) when is_list(Config) ->
      ?line Dog = test_server:timetrap(test_server:seconds(10)),
      ?line load_control_drv(Config),
      ?line P = open_port({spawn, control_drv}, []),
      ?line erlang:port_control(P, $b, [1]),	% Set to busy.
      Self = self(),
      ?line Echoer = spawn(fun() -> echoer(P, Self) end),
      ?line receive after 500 -> ok end,
      ?line erlang:port_control(P, $b, [0]),	% Set to not busy.
      ?line receive 
  	      {Echoer, done} ->
  		  ok;
  	      {Echoer, Other} ->
  		  test_server:fail(Other);
  	      Other ->
  		  test_server:fail({unexpected_message, Other})
  	  end,
      ?line test_server:timetrap_cancel(Dog),
      ok.
  
  echoer(P, ReplyTo) ->
  
negative.code:     Packet = erlang:port_control(P, $e, [unaligned_sub_bin(Bin)]).
  
  load_control_drv(Config) when is_list(Config) ->
      DataDir = ?config(data_dir, Config),
      erl_ddll:start(),
      ok = load_driver(DataDir, "control_drv").
  
  load_driver(Dir, Driver) ->
      case erl_ddll:load_driver(Dir, Driver) of
  