anchor.diff:      lists:map(StartFun, Nodes),
   
       ct:pal("Clustering nodes."),
  -    lists:map(fun(Node) -> cluster(Node, Nodes) end, Nodes),
  +    Manager = proplists:get_value(partisan_peer_service_manager, Options),
  +    lists:map(fun(Node) -> cluster(Node, Nodes, Manager) end, Nodes),
   
       ct:pal("Partisan fully initialized."),
   
  
positive.code: %% client/server topology, which requires all nodes talk to every other
  %% node to correctly compute the overlay.
  %%
  cluster(Node, Nodes) when is_list(Nodes) ->
      lists:map(fun(OtherNode) -> cluster(Node, OtherNode) end, Nodes -- [Node]);
  cluster({_, Node}, {_, OtherNode}) ->
      PeerPort = rpc:call(OtherNode,
                          partisan_config,
  
negative.code:     %% Pause for clustering.
      timer:sleep(1000),
  
      %% Create new digraph.
      Graph = digraph:new(),
  
      %% Verify connectedness.
      %%
      ConnectFun = fun({_, Node}) ->
          {ok, ActiveSet} = rpc:call(Node, Manager, active, []),
          Active = sets:to_list(ActiveSet),
  
          %% Add vertexes and edges.
          [connect(Graph, Node, N) || {N, _, _} <- Active]
                   end,
  
      %% Build the graph.
      lists:foreach(ConnectFun, Nodes),
  
      %% Verify connectedness.
      ConnectedFun = fun({_Name, Node}=Myself) ->
          lists:foreach(fun({_, N}) ->
              Path = digraph:get_short_path(Graph, Node, N),
              case Path of
                  false ->
                      ct:fail("Graph is not connected!");
                  _ ->
                      ok
              end
                        end, Nodes -- [Myself])
                     end,
      lists:foreach(ConnectedFun, Nodes),
  
      %% Verify symmetry.
      SymmetryFun = fun({_, Node1}) ->
          %% Get first nodes active set.
          {ok, ActiveSet1} = rpc:call(Node1, Manager, active, []),
          Active1 = sets:to_list(ActiveSet1),
  
          lists:foreach(fun({Node2, _, _}) ->
              %% Get second nodes active set.
              {ok, ActiveSet2} = rpc:call(Node2, Manager, active, []),
              Active2 = sets:to_list(ActiveSet2),
  
              case lists:member(Node1, [N || {N, _, _} <- Active2]) of
                  true ->
                      ok;
                  false ->
                      ct:fail("~p has ~p in it's view but ~p does not have ~p in its view",
                              [Node1, Node2, Node2, Node1])
              end
                        end, Active1)
                    end,
      lists:foreach(SymmetryFun, Nodes),
  
      %% Stop nodes.
      stop(Nodes),
  