anchor.diff:  
   %% Tests the port_connect/2 BIF.
   connect(Config) when is_list(Config) ->
  -    ?line load_control_drv(Config),
  -
  -    ?line P = open_port({spawn, control_drv}, []),
  +    load_control_drv(Config),
  +
  +    P = open_port({spawn, control_drv}, []),
       register(myport, P),
   
  -    ?line true = erlang:port_connect(myport, self()),
  +    true = erlang:port_connect(myport, self()),
   
       %% Connect the port to another process.
   
       Data = "hello, world",
       Parent = self(),
  -    ?line Rec =
  -	fun(Me) -> receive
  -		       {P,{data,Data}} ->
  -			   Parent ! connect_ok,
  -			   Me(Me)
  -		   end
  -	end,
  -    ?line RecPid = spawn_link(fun() -> Rec(Rec) end),
  -    ?line true = erlang:port_connect(P, RecPid),
  -    ?line unlink(P),
  +    Rec = fun(Me) ->
  +	    receive
  +		{P,{data,Data}} ->
  +		    Parent ! connect_ok,
  +		    Me(Me)
  +	    end
  +    end,
  +    RecPid = spawn_link(fun() -> Rec(Rec) end),
  +    true = erlang:port_connect(P, RecPid),
  +    unlink(P),
   
       %% Send a command to the port and make sure that the
       %% other process receives the echo.
   
  -    ?line erlang:port_command(P, Data),
  -    ?line receive
  -	      connect_ok -> ok
  -	  end,
  +    erlang:port_command(P, Data),
  +    receive
  +        connect_ok -> ok
  +    end,
   
       %% Tests some errors.
   
  -    ?line {'EXIT',{badarg, _}}=(catch erlang:port_connect(self(), self())),
  -    ?line {'EXIT',{badarg, _}}=(catch erlang:port_connect(self(), P)),
  -    ?line {'EXIT',{badarg, _}}=(catch erlang:port_connect(P, P)),
  -    ?line {'EXIT',{badarg, _}}=(catch erlang:port_connect(P, xxxx)),
  -    ?line {'EXIT',{badarg, _}}=(catch erlang:port_connect(P, [])),
  -
  -    ?line process_flag(trap_exit, true),
  -    ?line exit(P, you_should_die),
  -    ?line receive
  -	      {'EXIT',RecPid,you_should_die} -> ok;
  -	      Other -> ?line ?t:fail({bad_message,Other})
  -	  end,
  +    {'EXIT',{badarg, _}}=(catch erlang:port_connect(self(), self())),
  +    {'EXIT',{badarg, _}}=(catch erlang:port_connect(self(), P)),
  +    {'EXIT',{badarg, _}}=(catch erlang:port_connect(P, P)),
  +    {'EXIT',{badarg, _}}=(catch erlang:port_connect(P, xxxx)),
  +    {'EXIT',{badarg, _}}=(catch erlang:port_connect(P, [])),
  +
  +    process_flag(trap_exit, true),
  +    exit(P, you_should_die),
  +    receive
  +        {'EXIT',RecPid,you_should_die} -> ok;
  +        Other -> ?line ?t:fail({bad_message,Other})
  +    end,
   
       %% Done.
       ok.
   
   %% Tests port_control/3
   control(Config) when is_list(Config) ->
  -    ?line load_control_drv(Config),
  -    ?line P = open_port({spawn, control_drv}, []),
  +    load_control_drv(Config),
  +    P = open_port({spawn, control_drv}, []),
   
       %% Test invalid (out-of-range) arguments.
   
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(self(), 1, [])),
  -
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, -1, [])),
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, -34887348739733833, [])),
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, 16#100000000, [])),
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, a, [])),
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, 'e', dum)),
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, $e, dum)),
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, $e, fun(X) -> X end)),
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, $e,
  -							     [fun(X) -> X end])),
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, $e,
  -							     [1|fun(X) -> X end])),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(self(), 1, [])),
  +
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, -1, [])),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, -34887348739733833, [])),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, 16#100000000, [])),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, a, [])),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, 'e', dum)),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, $e, dum)),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, $e, fun(X) -> X end)),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, $e, [fun(X) -> X end])),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, $e, [1|fun(X) -> X end])),
   
       %% Test errors detected by the driver.
   
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, 177, [])),
  -    ?line {'EXIT', {badarg, _}} = (catch erlang:port_control(P, 155,
  -							     random_packet(1024))),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, 177, [])),
  +    {'EXIT', {badarg, _}} = (catch erlang:port_control(P, 155, random_packet(1024))),
   
       %% Test big op codes.
   
       register(myport, P),
  -    ?line test_op(myport, 256),
  -    ?line test_op(P, 256),
  -    ?line test_op(P, 16#0033A837),
  -    ?line test_op(P, 16#0ab37938),
  -    ?line test_op(P, 16#eab37938),
  -    ?line test_op(P, 16#ffffFFFF),
  +    test_op(myport, 256),
  +    test_op(P, 256),
  +    test_op(P, 16#0033A837),
  +    test_op(P, 16#0ab37938),
  +    test_op(P, 16#eab37938),
  +    test_op(P, 16#ffffFFFF),
   
       %% Test the echo function of the driver.
   
  -    ?line echo(P, 0),
  -    ?line echo(P, 1),
  -    ?line echo(P, 10),
  -    ?line echo(P, 13),
  -    ?line echo(P, 63),
  -    ?line echo(P, 64),
  -    ?line echo(P, 65),
  -    ?line echo(P, 127),
  -    ?line echo(P, 1023),
  -    ?line echo(P, 1024),
  -    ?line echo(P, 11243),
  -    ?line echo(P, 70000),
  +    echo(P, 0),
  +    echo(P, 1),
  +    echo(P, 10),
  +    echo(P, 13),
  +    echo(P, 63),
  +    echo(P, 64),
  +    echo(P, 65),
  +    echo(P, 127),
  +    echo(P, 1023),
  +    echo(P, 1024),
  +    echo(P, 11243),
  +    echo(P, 70000),
   
       %% Done.
   
  -    ?line true=erlang:port_close(myport),
  +    true = erlang:port_close(myport),
       ok.
   
   test_op(P, Op) ->
  
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
  