anchor.diff:      Node1 = hd(Cluster1),
       Node2 = hd(Cluster2),
       lists:foreach( fun(_) ->
  -                            multiple_writes(Node1, 1, 10, rpl)
  +                           multiple_writes(Node1, 1, 10, rpl)
                      end,
                      lists:seq(1,10)),
       WriteResult3 = rpc:call(Node1,
  -                           floppy, append,
  -                           [key1, riak_dt_gcounter, {increment, ucl}]),
  +                            floppy, append,
  +                            [key1, riak_dt_gcounter, {increment, ucl}]),
       ?assertMatch({ok, _}, WriteResult3),
       {ok,{_,_,CommitTime}}=WriteResult3,
   
  
positive.code: 
      {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),
  
negative.code:     simple_replication_test(Cluster1, Cluster2),
      multiple_keys_test(Cluster1, Cluster2),
      causality_test(Cluster1,Cluster2),
      atomicity_test(Cluster1,Cluster2),
      pass.
  
  simple_replication_test(Cluster1, Cluster2) ->
      Node1 = hd(Cluster1),
      Node2 = hd(Cluster2),
      WriteResult1 = rpc:call(Node1,
                              floppy, append,
                              [key1, riak_dt_gcounter, {increment, ucl}]),
      ?assertMatch({ok, _}, WriteResult1),
      WriteResult2 = rpc:call(Node1,
                              floppy, append,
                              [key1, riak_dt_gcounter, {increment, ucl}]),
      ?assertMatch({ok, _}, WriteResult2),
      WriteResult3 = rpc:call(Node1,
                              floppy, append,
                              [key1, riak_dt_gcounter, {increment, ucl}]),
      ?assertMatch({ok, _}, WriteResult3),
      {ok,{_,_,CommitTime}}=WriteResult3,
      Result = rpc:call(Node1, floppy, read,
                        [key1, riak_dt_gcounter]),
      ?assertEqual({ok, 3}, Result),
  
      ReadResult = rpc:call(Node2,
                            floppy, clocksi_read,
                            [CommitTime, key1, riak_dt_gcounter]),
      {ok, {_,[ReadSet],_} }= ReadResult,
      ?assertEqual(3, ReadSet),
      lager:info("Simple replication test passed!"),
  