anchor.diff:  %%     end,
       
       % cleanup
  +    stop_drop_read_op_on_key(HashedKeyToExclude),
       _ = [begin
                comm:send_local(DhtNode, {delete_keys, comm:make_global(self()), HashedKeys}),
                receive {delete_keys_reply} -> ok end
            end || DhtNode <- pid_groups:find_all(dht_node)],
       wait_for_dht_entries(0),
       ok.
  +
  +drop_read_op_on_key(HashedKey) ->
  +    ct:pal("Silencing key ~p~n", [HashedKey]),
  +    Self = self(),
  +    SkipHashedKeyFun =
  +        fun (Message, _State) ->
  +                 case Message of
  +                     {?read_op, _Source_PID, _SourceId, HashedKey, _Op} ->
  +                         ct:pal("Detected read, dropping it ~p, key ~p~n",
  +                                [self(), HashedKey]),
  +                         comm:send_local(Self, {drop_read_op_on_key, HashedKey, done}),
  +                         drop_single;
  +                     {?read_op, _Source_PID, _SourceId, HashedKey2, _Op} ->
  +                         ct:pal("Detected read ~p, key ~p~n",
  +                                [self(), HashedKey2]),
  +                         false;
  +                     _ ->
  +%%                          ct:pal("Let pass ~p~n", [Message]),
  +                         false
  +                 end
  +        end,
  +    
  +    _ = [gen_component:bp_set_cond(DhtNode, SkipHashedKeyFun, drop_read_op_on_key)
  +        || DhtNode <- pid_groups:find_all(dht_node)],
  +    ok.
  +
  +stop_drop_read_op_on_key(HashedKey) ->
  +    ct:pal("Reactivating ~p~n", [HashedKey]),
  +    _ = [gen_component:bp_del(DhtNode, drop_read_op_on_key)
  +        || DhtNode <- pid_groups:find_all(dht_node)],
  +    cleanup_drop_read_op_on_key(HashedKey).
  +
  +cleanup_drop_read_op_on_key(HashedKey) ->
  +    receive {drop_read_op_on_key, HashedKey, done} -> cleanup_drop_read_op_on_key(HashedKey)
  +    after 0 -> ok end.
   
   -spec prop_encode_decode(Value::client_value()) -> boolean().
   prop_encode_decode(Value) ->
  
positive.code: read_write_notfound(_Config) ->
      Key = "read_write_notfound_test_a",
      HashedKeys = ?RT:get_replica_keys(?RT:hash_key(Key)),
      _ = [read_write_notfound_test(Key, HashedKeys, HK, single) || HK <- HashedKeys],
      _ = [read_write_notfound_test(Key, HashedKeys, HK, req_list) || HK <- HashedKeys],
      ok.
  
  -spec read_write_notfound_test(Key::client_key(), HashedKeys::?RT:key(), HashedKeyToExclude::?RT:key(), Mode::single | req_list) -> ok.
  read_write_notfound_test(Key, HashedKeys, HashedKeyToExclude, Mode) ->
      Note = io_lib:format("Key: ~p, Hashed: ~p, Excl.: ~p, Mode: ~p",
                           [Key, HashedKeys, HashedKeyToExclude, Mode]),
  
negative.code:          end || DhtNode <- pid_groups:find_all(dht_node)],
      
      % test
      case HashedKeyToExclude of
          none -> ok;
          _    -> drop_read_op_on_key(HashedKeyToExclude)
      end,
      case Mode of
          single ->
              ct:pal("read"),
  