anchor.diff:                          []),
       lager:info("Tx2 Started, id : ~p", [TxId1]),
       lager:info("Tx2 Reading..."),
  -    Pid=spawn(?MODULE, spawn_read, [LastNode, TxId1, self()]),
  +    Pid=spawn(?MODULE, spawn_read, [LastNode, TxId1, self(), Key1]),
       %% Delay first transaction
       timer:sleep(100),
       %% commit the first tx.
  
positive.code:     lager:info("Test read_wait passed"),
      pass.
  
  spawn_read(LastNode, TxId, Return) ->
      ReadResult=rpc:call(LastNode, antidote, clocksi_iread,
                          [TxId, read_wait_test, riak_dt_pncounter]),
      Return ! {self(), ReadResult}.
  
  %% @doc The following function tests the certification check algorithm,
  %%      when two concurrent txs modify a single object, one hast to abort.
  clocksi_test_certification_check(Nodes) ->
      lager:info("clockSI_test_certification_check started"),
      FirstNode = hd(Nodes),
      LastNode= lists:last(Nodes),
      lager:info("Node1: ~p", [FirstNode]),
  
negative.code:     FirstNode = hd(Nodes),
      lager:info("Test2 started"),
      Type = riak_dt_pncounter,
      Key1=clocksi_test2_key1,
      Key2=clocksi_test2_key2,
      Key3=clocksi_test2_key3,
      {ok,TxId}=rpc:call(FirstNode, antidote, clocksi_istart_tx, []),
      ReadResult0=rpc:call(FirstNode, antidote, clocksi_iread,
                           [TxId, Key1, riak_dt_pncounter]),
      ?assertEqual({ok, 0}, ReadResult0),
      WriteResult=rpc:call(FirstNode, antidote, clocksi_iupdate,
                           [TxId, Key1, Type, {increment, 4}]),
      ?assertEqual(ok, WriteResult),
      ReadResult=rpc:call(FirstNode, antidote, clocksi_iread,
                          [TxId, Key1, riak_dt_pncounter]),
      ?assertEqual({ok, 1}, ReadResult),
      WriteResult1=rpc:call(FirstNode, antidote, clocksi_iupdate,
                            [TxId, Key2, Type, {increment, 4}]),
      ?assertEqual(ok, WriteResult1),
      ReadResult1=rpc:call(FirstNode, antidote, clocksi_iread,
                           [TxId, Key2, riak_dt_pncounter]),
      ?assertEqual({ok, 1}, ReadResult1),
      WriteResult2=rpc:call(FirstNode, antidote, clocksi_iupdate,
                            [TxId, Key3, Type, {increment, 4}]),
      ?assertEqual(ok, WriteResult2),
      ReadResult2=rpc:call(FirstNode, antidote, clocksi_iread,
                           [TxId, Key3, riak_dt_pncounter]),
      ?assertEqual({ok, 1}, ReadResult2),
      CommitTime=rpc:call(FirstNode, antidote, clocksi_iprepare, [TxId]),
      ?assertMatch({ok, _}, CommitTime),
  