anchor.diff:      rt:update_app_config(all,[
           {riak_core, [{ring_creation_size, NumVNodes}]}
       ]),
  +
  +    Clean = rt_config:get(clean_cluster, true),
  +
       [Cluster1, Cluster2] = rt:build_clusters([1,1]),
  -
  -    Node1 = hd(Cluster1),
  -    Node2 = hd(Cluster2),
  -
  -    rt:wait_until_registered(Node1, inter_dc_manager),
  -    rt:wait_until_registered(Node2, inter_dc_manager),
  -    
  -    {ok, DC1} = rpc:call(Node1, inter_dc_manager, start_receiver,[8091]),
  -    {ok, DC2} = rpc:call(Node2, inter_dc_manager, start_receiver,[8092]),
  -
  -    lager:info("DCs: ~p and ~p", [DC1, DC2]),
   
       rt:wait_until_ring_converged(Cluster1),
       rt:wait_until_ring_converged(Cluster2),
   
  -    lager:info("Waiting until vnodes are started up"),
  -    rt:wait_until(Node1,fun wait_init:check_ready/1),
  -    rt:wait_until(Node2,fun wait_init:check_ready/1),
  -    lager:info("Vnodes are started up"),
  -
  -    ok = rpc:call(Node1, inter_dc_manager, add_dc,[DC2]),
  -    ok = rpc:call(Node2, inter_dc_manager, add_dc,[DC1]),
  -
  +    ok = common:setup_dc_manager([Cluster1, Cluster2], [8091, 8092], true),
       simple_replication_test(Cluster1, Cluster2),
  -    multiple_keys_test(Cluster1, Cluster2),
  -    causality_test(Cluster1,Cluster2),
  -    atomicity_test(Cluster1,Cluster2),
  +
  +    [Cluster3, Cluster4] = common:clean_clusters([Cluster1, Cluster2]),
  +    ok = common:setup_dc_manager([Cluster3, Cluster4], [8091, 8092], Clean),
  +    multiple_keys_test(Cluster3, Cluster4),
  +
  +    [Cluster5, Cluster6] = common:clean_clusters([Cluster3, Cluster4]),
  +    ok = common:setup_dc_manager([Cluster5, Cluster6], [8091, 8092], Clean),
  +    causality_test(Cluster5, Cluster6),
  +
  +    [Cluster7, Cluster8] = common:clean_clusters([Cluster5, Cluster6]),
  +    ok = common:setup_dc_manager([Cluster7, Cluster8], [8091, 8092], Clean),
  +    atomicity_test(Cluster7, Cluster8),
       pass.
   
   simple_replication_test(Cluster1, Cluster2) ->
       Node1 = hd(Cluster1),
       Node2 = hd(Cluster2),
  +    Key = simple_replication_test,
       WriteResult1 = rpc:call(Node1,
                               antidote, append,
  -                            [key1, riak_dt_gcounter, {increment, ucl1}]),
  +                            [Key, riak_dt_gcounter, {increment, ucl1}]),
       ?assertMatch({ok, _}, WriteResult1),
       WriteResult2 = rpc:call(Node1,
                               antidote, append,
  -                            [key1, riak_dt_gcounter, {increment, ucl2}]),
  +                            [Key, riak_dt_gcounter, {increment, ucl2}]),
       ?assertMatch({ok, _}, WriteResult2),
       WriteResult3 = rpc:call(Node1,
                               antidote, append,
  -                            [key1, riak_dt_gcounter, {increment, ucl3}]),
  +                            [Key, riak_dt_gcounter, {increment, ucl3}]),
       ?assertMatch({ok, _}, WriteResult3),
       {ok,{_,_,CommitTime}}=WriteResult3,
       Result = rpc:call(Node1, antidote, read,
  -                      [key1, riak_dt_gcounter]),
  +                      [Key, riak_dt_gcounter]),
       ?assertEqual({ok, 3}, Result),
   
       ReadResult = rpc:call(Node2,
                             antidote, clocksi_read,
  -                          [CommitTime, key1, riak_dt_gcounter]),
  +                          [CommitTime, Key, riak_dt_gcounter]),
       {ok, {_,[ReadSet],_} }= ReadResult,
       ?assertEqual(3, ReadSet),
       lager:info("Simple replication test passed!"),
  
positive.code: atomicity_test(Cluster1, Cluster2) ->
      Node1 = hd(Cluster1),
      Node2 = hd(Cluster2),
      Key1 = a,
      Key2 = b,
      Key3 = c,
      Caller = self(),
      ContWrite = fun() ->
                          lists:foreach(
  
negative.code: multiple_keys_test(Cluster1, Cluster2) ->
      Node1 = hd(Cluster1),
      Node2 = hd(Cluster2),
      Key = multiple_keys_test,
      lists:foreach( fun(_) ->
                             multiple_writes(Node1, Key, 1, 10, rpl)
                     end,
                     lists:seq(1,10)),
      WriteResult3 = rpc:call(Node1,
                              antidote, append,
                              [Key, riak_dt_gcounter, {increment, ucl1}]),
      ?assertMatch({ok, _}, WriteResult3),
      {ok,{_,_,CommitTime}}=WriteResult3,
  
      Result1 = multiple_reads(Node1, Key, 1, 10, 10,CommitTime),
      ?assertEqual(length(Result1), 0),
      Result2 = multiple_reads(Node2, Key, 1, 10, 10, CommitTime),
      ?assertEqual(length(Result2), 0),
      lager:info("Multiple key read-write test passed!"),
      pass.
  
  multiple_writes(Node, PreKey, Start, End, Actor)->
      F = fun(N, Acc) ->
                  Key = list_to_atom(atom_to_list(PreKey) ++ [N]),
                  case rpc:call(Node, antidote, append,
                                [Key, riak_dt_gcounter,
                                 {{increment, 1}, Actor}]) of
                      {ok, _} ->
                          Acc;
                      Other ->
                          [{Key, Other} | Acc]
                  end
          end,
      lists:foldl(F, [], lists:seq(Start, End)).
  
  multiple_reads(Node, PreKey, Start, End, Total, CommitTime) ->
      F = fun(N, Acc) ->
                  Key = list_to_atom(atom_to_list(PreKey) ++ [N]),
                  case rpc:call(Node, antidote, clocksi_read, [CommitTime, Key, riak_dt_gcounter]) of
                      {error, _} ->
                          [{Key, error} | Acc];
                      {ok, {_,[Value],_}} ->
                          ?assertEqual(Value, Total),
                          Acc
  