anchor.diff:  
     ?assertMatch(ok, Status),
     ?assertEqual([20], Payload).
  +
  +read_log_test(Node) ->
  +  Key = ?KEY(read_log),
  +  BaseValue = initial_value,
  +
  +  Updates = 15,
  +  UpdateTxs = lists:map(
  +    fun(N) -> blocking_read_write_tx(Node, {Key, N}) end,
  +    lists:seq(0, Updates)
  +  ),
  +
  +  %% First, set the key to some initial value we can validate later
  +  _ = execute_blocking_sequential([blocking_read_write_tx(Node, {Key, BaseValue})]),
  +
  +  %% Validate that the base value went through
  +  {{Status, _}, {_, Payload}} = execute_blocking_sequential(blocking_read_only_tx(Node, Key)),
  +  ?assertMatch(ok, Status),
  +  ?assertEqual([BaseValue], Payload),
  +
  +  %% Now start a long-running transaction
  +  {ok, Tx} = start_transaction(Node),
  +
  +  %% Pick up a dependency on the previous transaction
  +  {ok, Read1} = read_objects(Node, Tx, Key),
  +  ?assertEqual([BaseValue], Read1),
  +
  +  timer:sleep(100),
  +
  +  %% Now stress the partition by forcing it to garbage collect
  +  Res = execute_blocking_sequential(UpdateTxs),
  +  ?assert(lists:all(fun({{ok, _}, _}) -> true; (_) -> false end, Res)),
  +
  +  %% Now read again. Because we picked up an empty clock,
  +  %% the snapshot should no longer be in memory, and has to
  +  %% be retrieved from the event log.
  +  {ok, SecondRead} = read_objects(Node, Tx, Key),
  +  ?assertEqual([BaseValue], SecondRead),
  +
  +  {ok, []} = commit_transaction(Node, Tx),
  +  ok.
   
   %% Util functions
   
  
positive.code: write_write_check(Node) ->
    ConflictKey = ?KEY(conflict),
    Res = execute_parallel([
      read_write_tx(Node, ConflictKey, 1),
      read_write_tx(Node, ConflictKey, 2)
    ]),
  
    CTRes = lists:map(fun({CT, _}) -> CT end, Res),
  
negative.code:     ])
    end.
  
  blocking_read_only_tx(Node, Key) ->
    fun() ->
      blocking_transaction(Node, [
        fun(T, _) -> read_objects(Node, T, Key) end
      ])
    end.
  
  collect(Processes, Results) ->
    case Processes of
  