anchor.diff:  multiple_keys_test(Cluster1, Cluster2) ->
       Node1 = hd(Cluster1),
       Node2 = hd(Cluster2),
  +    Key = multiple_keys_test,
       lists:foreach( fun(_) ->
  -                           multiple_writes(Node1, 1, 10, rpl)
  +                           multiple_writes(Node1, Key, 1, 10, rpl)
                      end,
                      lists:seq(1,10)),
       WriteResult3 = rpc:call(Node1,
                               antidote, append,
  -                            [key1, riak_dt_gcounter, {increment, ucl1}]),
  +                            [Key, riak_dt_gcounter, {increment, ucl1}]),
       ?assertMatch({ok, _}, WriteResult3),
       {ok,{_,_,CommitTime}}=WriteResult3,
   
  -    Result1 = multiple_reads(Node1, 1, 10, 10,CommitTime),
  +    Result1 = multiple_reads(Node1, Key, 1, 10, 10,CommitTime),
       ?assertEqual(length(Result1), 0),
  -    Result2 = multiple_reads(Node2, 1, 10, 10, CommitTime),
  +    Result2 = multiple_reads(Node2, Key, 1, 10, 10, CommitTime),
       ?assertEqual(length(Result2), 0),
       lager:info("Multiple key read-write test passed!"),
       pass.
   
  -multiple_writes(Node, Start, End, Actor)->
  +multiple_writes(Node, PreKey, Start, End, Actor)->
       F = fun(N, Acc) ->
  +                Key = list_to_atom(atom_to_list(PreKey) ++ [N]),
                   case rpc:call(Node, antidote, append,
  -                              [N, riak_dt_gcounter,
  +                              [Key, riak_dt_gcounter,
                                  {{increment, 1}, Actor}]) of
                       {ok, _} ->
                           Acc;
                       Other ->
  -                        [{N, Other} | Acc]
  +                        [{Key, Other} | Acc]
                   end
           end,
       lists:foldl(F, [], lists:seq(Start, End)).
   
  -multiple_reads(Node, Start, End, Total, CommitTime) ->
  +multiple_reads(Node, PreKey, Start, End, Total, CommitTime) ->
       F = fun(N, Acc) ->
  -                case rpc:call(Node, antidote, clocksi_read, [CommitTime, N, riak_dt_gcounter]) of
  +                Key = list_to_atom(atom_to_list(PreKey) ++ [N]),
  +                case rpc:call(Node, antidote, clocksi_read, [CommitTime, Key, riak_dt_gcounter]) of
                       {error, _} ->
  -                        [{N, error} | Acc];
  +                        [{Key, error} | Acc];
                       {ok, {_,[Value],_}} ->
                           ?assertEqual(Value, Total),
                           Acc
  
positive.code: atomicity_test(Cluster1, Cluster2) ->
      Node1 = hd(Cluster1),
      Node2 = hd(Cluster2),
      Key1 = a,
      Key2 = b,
      Key3 = c,
      Caller = self(),
      ContWrite = fun() ->
                          lists:foreach(
  
negative.code:     %% result set should not contain e
      Node1 = hd(Cluster1),
      Node2 = hd(Cluster2),
      Key = causality_test,
      %% Add two elements in DC1
      AddResult1 = rpc:call(Node1,
                            antidote, append,
  