anchor.diff:      %% Pause for clustering.
       timer:sleep(1000),
   
  -    %% Verify membership.
  -    %%
  -    %% Every node should know about every other node in this topology
  -    %% when the active setting is high.
  -    %%
  -    VerifyFun = fun({_, Node}) ->
  -            {ok, Members} = rpc:call(Node, Manager, members, []),
  -            SortedNodes = lists:usort([N || {_, N} <- Nodes]),
  -            SortedMembers = lists:usort(Members),
  -            case SortedMembers =:= SortedNodes of
  +    %% 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("Membership incorrect; node ~p should have ~p but has ~p", [Node, Nodes, Members])
  -            end
  -    end,
  -
  -    %% Verify the membership is correct.
  -    lists:foreach(VerifyFun, Nodes),
  +                    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),
  
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:     lists:map(StartFun, Nodes),
  
      ct:pal("Clustering 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."),
  
  