anchor.diff:      %% Start node A with different cookie
       %% and cookie configuration of mother node
       NodeAName = BaseName++"_nodeA",
  -    NodeA = list_to_atom(NodeAName++"@"++HostL),
  +    NodeA = full_node_name(NodeAName),
       NodeACookieL = BaseName++"_cookieA",
       NodeACookie = list_to_atom(NodeACookieL),
       { ok, NodeA } =
  
positive.code:     {comment, lists:flatten(io_lib:format("Reason: ~p", [Reason]))}.
  
  differing_cookies(Config) when is_list(Config) ->
      Node = node(),
      true = Node =/= nonode@nohost,
      NodeL = atom_to_list(Node),
      [ _, HostL ] = string:lexemes(NodeL, "@"),
      BaseName = atom_to_list(?FUNCTION_NAME),
  
      %% Use -hidden nodes to avoid global connecting all nodes
  
      %% Start node A with different cookie
      NodeAName = BaseName++"_nodeA",
      NodeA = list_to_atom(NodeAName++"@"++HostL),
      NodeACookieL = BaseName++"_cookieA",
      NodeACookie = list_to_atom(NodeACookieL),
      true = erlang:set_cookie( NodeA, NodeACookie ),
  
negative.code:     end,
      [] = nodes(),
      ok.
  
  dyn_differing_cookies(Config) when is_list(Config) ->
      test_server:timetrap({minutes, 1}),
      MotherNode = node(),
      true = MotherNode =/= nonode@nohost,
      [] = nodes(hidden),
      MotherNodeL = atom_to_list(MotherNode),
      BaseName = atom_to_list(?FUNCTION_NAME),
      MotherNodeCookie = erlang:get_cookie(),
      MotherNodeCookieL = atom_to_list(MotherNodeCookie),
      register(?FUNCTION_NAME, self()),
  
      %% Start node A with different cookie
      %% and cookie configuration of mother node
      DynNodeCookieL = BaseName++"_cookieA",
      DynNodeCookie = list_to_atom(DynNodeCookieL),
      {_NF, Port} =
          start_node_unconnected(
            "-setcookie "++MotherNodeL++" "++MotherNodeCookieL,
            undefined, DynNodeCookie,
            ?MODULE, run_remote_test,
            [atom_to_list(?FUNCTION_NAME), MotherNodeL] ),
  
      dyn_differing_cookies(MotherNode, MotherNodeCookie, DynNodeCookie, Port).
  
  dyn_differing_cookies(MotherNode, MotherNodeCookie, DynNodeCookie, Port) ->
      receive
          { MotherNode, MotherNodeCookie, DynNodeCookie, DynNode } ->
              [ DynNode ] = nodes(hidden),
              [ MotherNode ] = rpc:call( DynNode, erlang, nodes, [hidden] ),
              DynNodeCookie = rpc:call( DynNode, erlang, get_cookie, [] ),
              MotherNodeCookie =
                  rpc:call( DynNode, erlang, get_cookie, [MotherNode] ),
              {?FUNCTION_NAME, DynNode} !
                  {MotherNode, MotherNodeCookie, DynNode},
  
              0 = wait_for_port_exit(Port),
  
              [] = nodes(hidden),
              ok;
          {Port, {data, Data}} ->
              io:format("~p: ~s", [Port, Data]),
              dyn_differing_cookies(
                MotherNode, MotherNodeCookie, DynNodeCookie, Port);
          Other ->
              error({unexpected, Other})
      end.
  
  dyn_differing_cookies(MotherNode, _Args) ->
      nonode@nohost = node(),
      [] = nodes(hidden),
      true = net_kernel:connect_node( MotherNode ),
      [ MotherNode ] = nodes(hidden),
      DynNode = node(),
      [ DynNode ] = rpc:call( MotherNode, erlang, nodes, [hidden] ),
      MotherNodeCookie = erlang:get_cookie( MotherNode ),
      MotherNodeCookie = rpc:call( MotherNode, erlang, get_cookie, [] ),
      %% Here we get the mother node's default cookie
      MotherNodeCookie = rpc:call( MotherNode, erlang, get_cookie, [DynNode] ),
      DynNodeCookie = erlang:get_cookie(),
      register( ?FUNCTION_NAME, self() ),
      {?FUNCTION_NAME, MotherNode} !
          {MotherNode, MotherNodeCookie, DynNodeCookie, DynNode},
      receive
          { MotherNode, MotherNodeCookie, DynNode } ->
              true = disconnect_node( MotherNode ),
              [] = nodes(hidden),
              ok;
          Other ->
              error({unexpected, Other})
      end.
  
  
  %% Misc. functions
  