anchor.diff:                     monitor_node(Node, true),
                      Pid = spawn_link(Node, TC),
                      receive
  +                       %% No test case could/would provoke a nodedown => SKIP
                          {nodedown, Node} = N ->
  -                           exit(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),                           
  +                           monitor_node(Node, false),
                              exit(Reason)
                      end
              end,
       Post = fun(Node) ->
  -                   monitor_node(Node, true),
  -                   ?NPRINT("try stop node ~p", [Node]),
  -                   ?STOP_NODE(Node),
                      receive
                          {nodedown, Node} ->
  -                           ?NPRINT("node ~p stopped", [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).
  
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: 	       "SNMPv2-TC",
  	       "SNMPv2-TM"],
  
      ?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),
  
      ?SLEEP(2000),
      ?IPRINT("do_size_check -> display mem usage", []),
      ?line display_memory_usage(MibsPid),
      
      ?IPRINT("do_size_check -> unload (own) mibs", []),
      ?line unload_mibs(MibsPid, Mibs),
      ?IPRINT("do_size_check -> unload std mibs", []),
      ?line unload_mibs(MibsPid, StdMibs),
  
      ?IPRINT("do_size_check -> stop mib server", []),
      ?line mibs_stop(MibsPid),
      ?IPRINT("do_size_check -> stop symbolic store", []),
      ?line sym_stop(),
  
      ?IPRINT("do_size_check -> done", []),
  