anchor.diff:  
   %% Testserver specific export
   -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
  -	 init_per_group/2,end_per_group/2]).
  +	 init_per_group/2,end_per_group/2, init_per_testcase/2,
  +	 end_per_testcase/2]).
   
   %% Indirect spawn export
   -export([init/1]).
  
positive.code: end_per_group(_GroupName, Config) ->
      Config.
  
  
  
  start(InitResult) ->
  
negative.code:     
      ok.
  %-------------------------------------------------------------------------
  count_children_memory(doc) ->
      ["Test that which_children eats memory, but count_children does not."];
  count_children_memory(Config) when is_list(Config) ->
      process_flag(trap_exit, true),
      Child = {child, {supervisor_1, start_child, []}, temporary, 1000,
  	     worker, []},
      ?line {ok, _Pid} = start({ok, {{simple_one_for_one, 2, 3600}, [Child]}}),
      [supervisor:start_child(sup_test, []) || _Ignore <- lists:seq(1,1000)],
  
      garbage_collect(),
      _Size1 = erlang:memory(processes_used),
      Children = supervisor:which_children(sup_test),
      _Size2 = erlang:memory(processes_used),
      ChildCount = get_child_counts(sup_test),
      Size3 = erlang:memory(processes_used),
  
      [supervisor:start_child(sup_test, []) || _Ignore2 <- lists:seq(1,1000)],
  
      garbage_collect(),
      Children2 = supervisor:which_children(sup_test),
      Size4 = erlang:memory(processes_used),
      ChildCount2 = get_child_counts(sup_test),
      Size5 = erlang:memory(processes_used),
  
      garbage_collect(),
      Children3 = supervisor:which_children(sup_test),
      Size6 = erlang:memory(processes_used),
      ChildCount3 = get_child_counts(sup_test),
      Size7 = erlang:memory(processes_used),
  
      ?line 1000 = length(Children),
      ?line [1,1000,0,1000] = ChildCount,
      ?line 2000 = length(Children2),
      ?line [1,2000,0,2000] = ChildCount2,
      ?line Children3 = Children2,
      ?line ChildCount3 = ChildCount2,
  
      %% count_children consumes memory using an accumulator function,
      %% but the space can be reclaimed incrementally, whereas
      %% which_children generates a return list.
      case (Size5 =< Size4) of
  	true -> ok;
  	false ->
  	    ?line test_server:fail({count_children, used_more_memory})
      end,
      case Size7 =< Size6 of
  	true -> ok;
  	false ->
  	    ?line test_server:fail({count_children, used_more_memory})
      end,
  
      case Size4 > Size3 of
  	true -> ok;
  	false ->
  	    ?line test_server:fail({which_children, used_no_memory})
      end,
      case Size6 > Size5 of
  	true -> ok;
  	false ->
  	    ?line test_server:fail({which_children, used_no_memory})
      end,
  
      [exit(Pid, kill) || {undefined, Pid, worker, _Modules} <- Children3],
      test_server:sleep(100),
      ?line [1,0,0,0] = get_child_counts(sup_test),
  
      ok.
  
  count_children_allocator_test(MemoryState) ->
      Allocators = [temp_alloc, eheap_alloc, binary_alloc, ets_alloc,
  		  driver_alloc, sl_alloc, ll_alloc, fix_alloc, std_alloc,
  