anchor.diff:      %%
       %% Every node should know about every other node in this topology.
       %%
  -    VerifyFun = fun({_, Node}) ->
  +    VerifyFun = fun({Name, Node}) ->
               {ok, Members} = rpc:call(Node, Manager, members, []),
  -            SortedNodes = lists:usort([N || {_, N} <- Nodes]),
  +
  +            %% If this node is a server, it should know about all nodes.
  +            SortedNodes = case lists:member(Name, Servers) of
  +                true ->
  +                    lists:usort([N || {_, N} <- Nodes]);
  +                false ->
  +                    %% Otherwise, it should only know about the server
  +                    %% and itself.
  +                    lists:usort(
  +                        lists:map(fun(S) ->
  +                                    proplists:get_value(S, Nodes)
  +                            end, Servers) ++ [Node])
  +            end,
  +
               SortedMembers = lists:usort(Members),
               case SortedMembers =:= SortedNodes of
                   true ->
  
positive.code:     lists:map(LoaderFun, Nodes),
  
      %% Configure settings.
      ConfigureFun = fun({_Name, Node}) ->
                          %% Configure the peer service.
                          PeerService = proplists:get_value(partisan_peer_service_manager, Options),
                          ct:pal("Setting peer service maanger on node ~p to ~p", [Node, PeerService]),
                          ok = rpc:call(Node, partisan_config, set,
                                        [partisan_peer_service_manager, PeerService])
                     end,
      lists:map(ConfigureFun, Nodes),
  
      ct:pal("Starting nodes."),
  
negative.code:     %% Use the client/server peer service manager.
      Manager = partisan_client_server_peer_service_manager,
  
      %% Specify servers.
      Servers = [rita],
  
      %% Specify clients.
      Clients = [bob, sue, jerome],
  
      %% Start nodes.
      Nodes = start(default_manager_test, Config,
                    [{partisan_peer_service_manager, Manager},
                     {servers, Servers},
                     {clients, Clients}]),
  
      %% Pause for clustering.
      timer:sleep(1000),
  