anchor.diff:  
       {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),
  
positive.code: 
  multiple_writes(Node, Start, End, Actor)->
      F = fun(N, Acc) ->
              case rpc:call(Node, floppy, append,
                            [N, riak_dt_gcounter,
                             {{increment, 1}, Actor}]) of
                  {ok, _} ->
                      Acc;
                  Other ->
                      [{N, Other} | Acc]
              end
      end,
      lists:foldl(F, [], lists:seq(Start, End)).
  
  multiple_reads(Node, Start, End, Total, CommitTime) ->
      F = fun(N, Acc) ->
              case rpc:call(Node, floppy, clocksi_read, [CommitTime, N, riak_dt_gcounter]) of
                  {error, _} ->
                      [{N, error} | Acc];
                  {ok, {_,[Value],_}} ->
                      ?assertEqual(Value, Total),
                      Acc
              end
      end,
      lists:foldl(F, [], lists:seq(Start, End)).
  
  causality_test(Cluster1, Cluster2) ->
  
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!"),
  