anchor.diff:      rt:wait_until_ring_converged(Cluster1),
       rt:wait_until_ring_converged(Cluster2),
       rt:wait_until_ring_converged(Cluster3),
  -    
  -    
  +
  +
       ok = rpc:call(HeadCluster1, inter_dc_manager, add_list_dcs,[[DC2, DC3]]),
       ok = rpc:call(HeadCluster2, inter_dc_manager, add_list_dcs,[[DC1, DC3]]),
       ok = rpc:call(HeadCluster3, inter_dc_manager, add_list_dcs,[[DC1, DC2]]),
  -    
  +
       simple_replication_test(Cluster1, Cluster2, Cluster3),
       pass.
   
  
positive.code:     Node1 = hd(Cluster1),
      Node2 = hd(Cluster2),
      Node3 = hd(Cluster3),
     % Result = rpc:call(Node2, inter_dc_communication_sup, start_link,[8091]),
     % lager:info("Sup start result ~p", [Result]),
      %%timer:sleep(10000), %% REMOVE this
      WriteResult1 = rpc:call(Node1,
                             floppy, append,
                             [key1, riak_dt_gcounter, {increment, ucl}]),
  
negative.code:                            floppy, append,
                             [key1, riak_dt_gcounter, {increment, ucl}]),
      ?assertMatch({ok, _}, WriteResult3),
      {ok,{_,_,CommitTime}}=WriteResult3,
      ReadResult = rpc:call(Node1, floppy, read,
                             [key1, riak_dt_gcounter]),
      ?assertEqual({ok, 3}, ReadResult),
  
      ReadResult2 = rpc:call(Node3,
                             floppy, clocksi_read,
                             [CommitTime, key1, riak_dt_gcounter]),
      {ok, {_,[ReadSet1],_} }= ReadResult2,
      ?assertEqual(3, ReadSet1),
  
      ReadResult3 = rpc:call(Node2,
                             floppy, clocksi_read,
                             [CommitTime, key1, riak_dt_gcounter]),
      {ok, {_,[ReadSet2],_} }= ReadResult3,
      ?assertEqual(3, ReadSet2),
  
      lager:info("Done first round of read, I am gonna append"),
      WriteResult4= rpc:call(Node2,
                             floppy, clocksi_bulk_update,
                             [ CommitTime,
                             [{update, key1, riak_dt_gcounter, {increment, ucl}}]]),
      ?assertMatch({ok, _}, WriteResult4),
      {ok,{_,_,CommitTime2}}=WriteResult4,
      lager:info("Done append in Node2"),
      WriteResult5= rpc:call(Node3,
                             floppy, clocksi_bulk_update,
                             [CommitTime2,
                             [{update, key1, riak_dt_gcounter, {increment, ucl}}]]),
      ?assertMatch({ok, _}, WriteResult5),
      {ok,{_,_,CommitTime3}}=WriteResult5,
      lager:info("Done append in Node3"),
      lager:info("Done waiting, I am gonna read"),
  
      SnapshotTime =
          CommitTime3,
      ReadResult4 = rpc:call(Node1,
                             floppy, clocksi_read,
                             [SnapshotTime, key1, riak_dt_gcounter]),
      {ok, {_,[ReadSet4],_} }= ReadResult4,
      ?assertEqual(5, ReadSet4),
  
      ReadResult5 = rpc:call(Node2,
                             floppy, clocksi_read,
                             [SnapshotTime,key1, riak_dt_gcounter]),
      {ok, {_,[ReadSet5],_} }= ReadResult5,
      ?assertEqual(5, ReadSet5),
      ReadResult6 = rpc:call(Node3,
                             floppy, clocksi_read,
                             [SnapshotTime,key1, riak_dt_gcounter]),
      {ok, {_,[ReadSet6],_} }= ReadResult6,
      ?assertEqual(5, ReadSet6),
      pass.
  