anchor.diff:          )
       end,
   
  -    lists:foreach(fun({_Name, Node}) ->
  -                        %% Get enabled parallelism.
  -                        Parallelism = rpc:call(Node, partisan_config, get, [parallelism, ?PARALLELISM]),
  -                        ct:pal("Parallelism is: ~p", [Parallelism]),
  -
  -                        %% Get enabled channels.
  -                        Channels = rpc:call(Node, partisan_config, get, [channels, ?CHANNELS]),
  -                        ct:pal("Channels are: ~p", [Channels]),
  -
  -                        lists:foreach(fun(Channel) ->
  -                            %% Generate fun.
  -                            VerifyConnectionsNodeFun = fun() ->
  -                                                            VerifyConnectionsFun(Node, Channel, Parallelism)
  -                                                    end,
  -
  -                            %% Wait until connections established.
  -                            case wait_until(VerifyConnectionsNodeFun, 60 * 2, 100) of
  -                                ok ->
  -                                    ok;
  -                                _ ->
  -                                    ct:fail("Not enough connections have been opened; need: ~p", [Parallelism])
  -                            end
  -                        end, Channels)
  -                  end, Nodes),
  +    lists:foreach(
  +        fun({_Name, Node}) ->
  +            %% Get enabled parallelism.
  +            Parallelism = rpc:call(
  +                Node, partisan_config, get, [parallelism, ?PARALLELISM]
  +            ),
  +            ct:pal("Parallelism is: ~p", [Parallelism]),
  +
  +            %% Get enabled channels.
  +            Channels = rpc:call(
  +                Node, partisan_config, get, [channels, ?CHANNELS]
  +            ),
  +            ct:pal("Channels are: ~p", [Channels]),
  +
  +            lists:foreach(fun(Channel) ->
  +                %% Generate fun.
  +                VerifyConnectionsNodeFun = fun() ->
  +                    VerifyConnectionsFun(Node, Channel, Parallelism)
  +                end,
  +
  +                %% Wait until connections established.
  +                case wait_until(VerifyConnectionsNodeFun, 60 * 2, 100) of
  +                    ok ->
  +                        ok;
  +                    _ ->
  +                        ct:fail("Not enough connections have been opened; need: ~p", [Parallelism])
  +                end
  +            end, Channels)
  +        end,
  +        Nodes
  +    ),
   
       %% Stop nodes.
       ?SUPPORT:stop(Nodes),
  
positive.code: 
          %% Verify we have enough connections.
          partisan_peer_service_connections:fold(
              fun(_N, Active, Acc) ->
                  Filtered = lists:filter(fun({_, C, _}) ->
                      case C of
                          Channel ->
                              true;
                          _ ->
                              false
                      end
                  end, Active),
  
                  case length(Filtered) == Parallelism of
                      true ->
                          Acc andalso true;
                      false ->
  
negative.code:     ct:pal("Configured channels: ~p", [ConfigChannels]),
  
      ConnectionsFun = fun(Node) ->
          rpc:call(Node, ?DEFAULT_PEER_SERVICE_MANAGER, connections, [])
      end,
  
      VerifyConnectionsFun = fun(Node, Channel, Parallelism) ->
          %% Get list of connections.
  