anchor.diff:      % Write A: Write only to replica 1
       ct:pal("partial write to replica 1"),
       print_prbr_data(),
  -    [get_notified_by_message(self(), 1, kv_db, I, dht_node, write) || I<-lists:seq(1, 1)],
  -    _LinkA = [slow_link(1, kv_db, I, dht_node, write) || I <- lists:seq(2, 4)],
  +    get_notified_by_message(1, 1, write),
  +    _ = slow_link(1, [2, 3, 4], write),
       spawn(fun() -> write_via_node(1, Key, filter_list_append(), "WriteA") end),
  -    [receive {message_received} -> ok end || _ <- lists:seq(1, 1)],
  +    wait_until_notification(1),
       print_prbr_data(),
   
       %% Execute read B
       ct:pal("inconsistent read"),
  -    [get_notified_by_message(self(), 2, kv_db, I, dht_node, read) || I<-lists:seq(1, 1)],
  -    _LinkB = [slow_link(2, kv_db, I, dht_node, read) || I <- lists:seq(2, 4)],
  -    LinkC = slow_link(2, kv_db, 4, dht_node, round_request),
  +    get_notified_by_message(2, 1, read),
  +    _ = slow_link(2, [2,3,4], read),
  +    LinkC = slow_link(2, 4, round_request),
       spawn(fun() ->
           {ok, Value} = read_via_node(2, Key, element(1, filter_list_append())),
               TestPid ! {read_req_done, Value}
           end),
       % message_received -> internally seen inconsistent quorum and moved to read stage
  -    [receive {message_received} -> ok end || _ <- lists:seq(1, 1)],
  +    wait_until_notification(1),
       print_prbr_data(),
       %% deliver slow messages from replica 4
       ct:pal("remove slow link"),
  
positive.code:     %% Do a read over replica 1, 2, 3
      %% It should be an inconsistent read and currently diverging replica 1
      %% should be repaired,
      get_notified_by_message(self(), 4, kv_db, 4, dht_node, write),
      LinkD = slow_link(4, kv_db, 4, dht_node),
      {ok, _} = read_via_node(4, Key, element(1, filter_list_append())),
      remove_slow_link(LinkD),
      receive {message_received} -> ok end,
  
      ct:pal("PRBR state after inconsistent read: ~n~p", [prbr_data()]),
      PrbrData2 = prbr_values(),
  
negative.code:     %% triggered.
      Key = "123",
  
      % write baseline 
      get_notified_by_message(1, [1,2,3,4], write),
      _ = write_via_node(1, Key, {fun prbr:noop_read_filter/1,
                                  fun ?MODULE:cc_noop/3,
                                  fun prbr:noop_write_filter/3},
                         {"A", "B"}),
      wait_until_notification(4),
  
      _ = slow_link(1, 4, write),
      _ = write_via_node(1, Key, {fun ?MODULE:rf_second/1,
                                  fun ?MODULE:cc_noop/3,
                                  fun ?MODULE:wf_second/3}, "C"),
  
      PrbrValuesBeforeRead = prbr_values(),
      _ = slow_link(4, 1),
      {ok, "A"} = read_via_node(4, Key, fun ?MODULE:rf_first/1),
      PrbrValuesAfterRead = prbr_values(),
  
  