anchor.diff:         fun() ->
   	       compile_compiler(Files, OutDir, Version, Opts)
          end, Pa),
  -    ?line test_server:timetrap_cancel(Dog),
  +    test_server:timetrap_cancel(Dog),
       ok.
   
   compile_compiler(Files, OutDir, Version, InlineOpts) ->
  
positive.code:     [list_to_atom(filename:rootname(filename:basename(F))) || F <- Files].
  
  make_compiler_dir(Priv, Dir0) ->
      ?line Dir = filename:join(Priv, Dir0),
      ?line ok = file:make_dir(Dir),
      Dir.
  
  make_current(Dir) ->    
      true = code:add_patha(Dir),
      lists:foreach(fun(File) ->
  			  c:l(File)
  		  end, compiler_modules(Dir)),
      io:format("~p\n", [code:which(compile)]).
  
  compiler_version() ->
      {value,{version,Version}} = lists:keysearch(version, 1,
  						compile:module_info(compile)),
      Version.
  
  compare_compilers(ADir, BDir) ->
      {[],[],D} = beam_lib:cmp_dirs(ADir, BDir),
      [] = [T || {A,_}=T <- D,
  	       filename:basename(A) =/= "beam_asm.beam"]. %Contains compiler version.
  
  
  %%%
  %%% The only test of the following code is that it compiles.
  
negative.code:     self_compile_1(Config, "old", [verbose,{inline,500}]).
  
  self_compile_1(Config, Prefix, Opts) ->
      Dog = test_server:timetrap(test_server:minutes(40)),
  
      Priv = ?config(priv_dir,Config),
      Version = compiler_version(),
  
      %% Compile the compiler. (In this node to get better coverage.)
      CompA = make_compiler_dir(Priv, Prefix++"compiler_a"),
      VsnA = Version ++ ".0",
      compile_compiler(compiler_src(), CompA, VsnA, [clint0,clint|Opts]),
  
      %% Compile the compiler again using the newly compiled compiler.
      %% (In another node because reloading the compiler would disturb cover.)
      CompilerB = Prefix++"compiler_b",
      CompB = make_compiler_dir(Priv, CompilerB),
      VsnB = VsnA ++ ".0",
      self_compile_node(CompA, CompB, VsnB, Opts),
  
      %% Compare compiler directories. The compiler directories should
      %% be equal (except for beam_asm that contains the compiler version).
      compare_compilers(CompA, CompB),
  
      test_server:timetrap_cancel(Dog),
      ok.
  
  self_compile_node(CompilerDir, OutDir, Version, Opts) ->
      Dog = test_server:timetrap(test_server:minutes(15)),
      Pa = "-pa " ++ filename:dirname(code:which(?MODULE)) ++
  	" -pa " ++ CompilerDir,
      Files = compiler_src(),
  
      %% We don't want the cover server started on the other node,
      %% because it will load the same cover-compiled code as on this
  