anchor.diff:      {ok, {_,[ReadSet6],_} }= ReadResult6,
       ?assertEqual(5, ReadSet6),
       pass.
  +
  +parallel_writes_test(Cluster1, Cluster2, Cluster3) ->
  +    Node1 = hd(Cluster1),
  +    Node2 = hd(Cluster2),
  +    Node3 = hd(Cluster3),
  +    Key = parkey,
  +    Pid = self(),
  +    %% WriteFun = fun(A,B,C,D) ->
  +    %%                    multiple_writes(A,B,C,D)
  +    %%            end,
  +    spawn(?MODULE, multiple_writes,[Node1,Key, node1, Pid]),
  +    spawn(?MODULE, multiple_writes,[Node2,Key, node2, Pid]),
  +    spawn(?MODULE, multiple_writes,[Node3,Key, node3, Pid]),
  +    Result = receive
  +        {ok, CT1} ->
  +            receive
  +                {ok, CT2} ->
  +                receive
  +                    {ok, CT3} ->
  +                        Time = dict:merge(fun(_K, T1,T2) ->
  +                                                  max(T1,T2)
  +                                          end,
  +                                          CT3, dict:merge(
  +                                                 fun(_K, T1,T2) ->
  +                                                         max(T1,T2)
  +                                                 end,
  +                                                 CT1, CT2)),
  +                        ReadResult1 = rpc:call(Node1,
  +                           floppy, clocksi_read,
  +                           [Time, Key, riak_dt_gcounter]),
  +                        {ok, {_,[ReadSet1],_} }= ReadResult1,
  +                        ?assertEqual(15, ReadSet1),
  +                        ReadResult2 = rpc:call(Node2,
  +                           floppy, clocksi_read,
  +                           [Time, Key, riak_dt_gcounter]),
  +                        {ok, {_,[ReadSet2],_} }= ReadResult2,
  +                        ?assertEqual(15, ReadSet2),
  +                        ReadResult3 = rpc:call(Node3,
  +                           floppy, clocksi_read,
  +                           [Time, Key, riak_dt_gcounter]),
  +                        {ok, {_,[ReadSet3],_} }= ReadResult3,
  +                        ?assertEqual(15, ReadSet3),
  +                        lager:info("Parallel reads passed"),
  +                        pass
  +                after 10000 ->
  +                        lager:info("Timeout"),
  +                        timeout
  +                end
  +            after 10000 ->
  +                    lager:info("Timeout"),
  +                    timeout
  +            end
  +    after 10000 ->
  +            lager:info("Timeout"),
  +            timeout
  +    end,
  +    ?assertEqual(Result, pass),
  +    pass.
  +
  +multiple_writes(Node, Key, Actor, ReplyTo) ->
  +    WriteResult1 = rpc:call(Node,
  +                            floppy, append,
  +                            [Key, riak_dt_gcounter, {increment, Actor}]),
  +    ?assertMatch({ok, _}, WriteResult1),
  +    WriteResult2 = rpc:call(Node,
  +                            floppy, append,
  +                            [Key, riak_dt_gcounter, {increment, Actor}]),
  +    ?assertMatch({ok, _}, WriteResult2),
  +    WriteResult3 = rpc:call(Node,
  +                            floppy, append,
  +                            [Key, riak_dt_gcounter, {increment, Actor}]),
  +    ?assertMatch({ok, _}, WriteResult3),
  +    WriteResult4 = rpc:call(Node,
  +                            floppy, append,
  +                            [Key, riak_dt_gcounter, {increment, Actor}]),
  +    ?assertMatch({ok, _}, WriteResult4),
  +    WriteResult5 = rpc:call(Node,
  +                            floppy, append,
  +                            [Key, riak_dt_gcounter, {increment, Actor}]),
  +    ?assertMatch({ok, _}, WriteResult5),
  +    {ok,{_,_,CommitTime}}=WriteResult5,
  +    ReplyTo ! {ok, CommitTime}.
  
positive.code:     ok = rpc:call(HeadCluster3, inter_dc_manager, add_list_dcs,[[DC1, DC2]]),
  
      simple_replication_test(Cluster1, Cluster2, Cluster3),
      pass.
  
  simple_replication_test(Cluster1, Cluster2, Cluster3) ->
  
negative.code: -module(multiple_dcs_test).
  
  -export([confirm/0, multiple_writes/4]).
  
  -include_lib("eunit/include/eunit.hrl").
  
  