anchor.diff:  atomicity_test(Cluster1, Cluster2) ->
       Node1 = hd(Cluster1),
       Node2 = hd(Cluster2),
  -    Key1 = a,
  -    Key2 = b,
  -    Key3 = c,
  +    Key1 = atomicity_test1,
  +    Key2 = atomicity_test2,
  +    Key3 = atomicity_test3,
       Caller = self(),
       ContWrite = fun() ->
                           lists:foreach(
  
positive.code:     %% result set should not contain e
      Node1 = hd(Cluster1),
      Node2 = hd(Cluster2),
      Key = myset,
      %% Add two elements in DC1
      AddResult1 = rpc:call(Node1,
                            antidote, append,
  
negative.code:     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]),
  
      rt:wait_until_ring_converged(Cluster1),
      rt:wait_until_ring_converged(Cluster2),
  
      ok = common:setup_dc_manager([Cluster1, Cluster2], [8091, 8092], true),
      simple_replication_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,
                              [Key, riak_dt_gcounter, {increment, ucl1}]),
      ?assertMatch({ok, _}, WriteResult1),
      WriteResult2 = rpc:call(Node1,
                              antidote, append,
                              [Key, riak_dt_gcounter, {increment, ucl2}]),
      ?assertMatch({ok, _}, WriteResult2),
      WriteResult3 = rpc:call(Node1,
                              antidote, append,
                              [Key, riak_dt_gcounter, {increment, ucl3}]),
      ?assertMatch({ok, _}, WriteResult3),
      {ok,{_,_,CommitTime}}=WriteResult3,
      Result = rpc:call(Node1, antidote, read,
                        [Key, riak_dt_gcounter]),
      ?assertEqual({ok, 3}, Result),
  
      ReadResult = rpc:call(Node2,
                            antidote, clocksi_read,
                            [CommitTime, Key, riak_dt_gcounter]),
      {ok, {_,[ReadSet],_} }= ReadResult,
      ?assertEqual(3, ReadSet),
      lager:info("Simple replication test passed!"),
  