anchor.diff:  	       "SNMPv2-TC",
   	       "SNMPv2-TM"],
   
  -    ?DBG("do_size_check -> load mibs", []),
  +    ?IPRINT("do_size_check -> load std mibs", []),
  +    ?line load_mibs(MibsPid, StdMibDir, StdMibs),
  +    ?IPRINT("do_size_check -> load (own) mibs", []),
       ?line load_mibs(MibsPid, MibDir, Mibs),
  -    ?DBG("do_size_check -> load std mibs", []),
  -    ?line load_mibs(MibsPid, StdMibDir, StdMibs),
   
       ?SLEEP(2000),
  -    ?DBG("do_size_check -> display mem usage", []),
  +    ?IPRINT("do_size_check -> display mem usage", []),
       ?line display_memory_usage(MibsPid),
       
  -    ?DBG("do_size_check -> unload std mibs", []),
  +    ?IPRINT("do_size_check -> unload (own) mibs", []),
  +    ?line unload_mibs(MibsPid, Mibs),
  +    ?IPRINT("do_size_check -> unload std mibs", []),
       ?line unload_mibs(MibsPid, StdMibs),
  -    ?DBG("do_size_check -> unload mibs", []),
  -    ?line unload_mibs(MibsPid, Mibs),
  -
  -    ?DBG("do_size_check -> stop mib server", []),
  +
  +    ?IPRINT("do_size_check -> stop mib server", []),
       ?line mibs_stop(MibsPid),
  -    ?DBG("do_size_check -> stop symbolic store", []),
  +    ?IPRINT("do_size_check -> stop symbolic store", []),
       ?line sym_stop(),
   
       ?IPRINT("do_size_check -> done", []),
  
positive.code:     Verbosity = trace,
  
      MibStorage = ?config(mib_storage, Config),
      ?DBG("do_size_check -> MibStorage: ~p", [MibStorage]),
      MibDir     = ?config(data_dir, Config),
      StdMibDir  = filename:join(code:priv_dir(snmp), "mibs") ++ "/",
      
      ?DBG("do_size_check -> start symbolic store", []),
      ?line sym_start(Prio, MibStorage, Verbosity),
      ?DBG("do_size_check -> start mib server", []),
      ?line MibsPid = mibs_start(Prio, MibStorage, Verbosity),
  
      Mibs    = ["Test2", "TestTrap", "TestTrapv2"],
  
negative.code:                    monitor_node(Node, true),
                     Pid = spawn_link(Node, TC),
                     receive
                         %% No test case could/would provoke a nodedown => SKIP
                         {nodedown, Node} = N ->
                             ?NPRINT("unexpected node down ~p", [Node]),
                             exit({skip, N});
                         {'EXIT', Pid, normal} ->
                             monitor_node(Node, false),                           
                             ok;
                         {'EXIT', Pid, ok} ->
                             monitor_node(Node, false),                           
                             ok;
                         %% This is a node down.
                         %% Its just a race that this came before the actual
                         %% 'nodedown'.
                         %% Also, there is no normal test case that could provoke
                         %% a node down, so this is *not* our fault => SKIP
                         {'EXIT', Pid, noconnection = Reason} ->
                             ?NPRINT("unexpected '~p' termination", [Reason]),
                             monitor_node(Node, false), % Just in case
                             exit({skip, Reason});
                         {'EXIT', Pid, Reason} ->
                             monitor_node(Node, false),
                             exit(Reason)
                     end
             end,
      Post = fun(Node) ->
                     receive
                         {nodedown, Node} ->
                             ?NPRINT("node ~p (already) stopped", [Node]),
                             ok
                     after 0 ->
                             monitor_node(Node, true),
                             ?NPRINT("try stop node ~p", [Node]),
                             ?STOP_NODE(Node),
                             receive
                                 {nodedown, Node} ->
                                     ?NPRINT("node ~p stopped", [Node]),
                                     ok
                             end
                     end
             end,
      ?TC_TRY(Name, Pre, Case, Post).
  