anchor.diff:           {chash_keyfun, {riak_core_util, chash_std_keyfun}}]).
   
   %% Generators
  +
  +longer_list(K, G) ->
  +    ?SIZED(Size, resize(trunc(K*Size), list(resize(Size, G)))).
  +
  +non_empty(G) ->
  +    ?SUCHTHAT(X, G, X /= [] andalso X /= <<>>).
  +
  +largenat() ->
  +    ?LET(X, largeint(), abs(X)).
   
   n(Max) ->
       choose(1, Max).
  
positive.code:         NoReply  = length([ ok || {_, {error, timeout}}  <- History ]),
          H        = lists:map(fun({_, {ok, _}})      -> ok;
                              ({_, {error, Err}}) -> Err end, History),
          Expected = expect(H, N, R),
          ?WHENFAIL(
              io:format("N: ~p~nR: ~p~nQ: ~p~nResult: ~p~nHistory: ~p~nOk: ~p~nNotFound: ~p~nNoReply: ~p~nExpected: ~p~n",
                        [N, R, Q, Res, H, Ok, NotFound, NoReply, Expected]),
              conjunction(
                  [{result,
                      case Res of
                          {ok, Reply} ->
                              conjunction(
                                  [{object, equals(Reply, Object)},
                                   {ok, Expected =:= ok}]);
                          {error, timeout} ->
                              Expected =:= timeout;
                          {error, notfound} ->
                              Expected =:= notfound;
                          {anything, _Anything} ->
                              false;
                          timeout ->
                              false
                      end},
                  {n_value, equals(length(History), N)}
                  ]))
      end).
  
  wait_for_req_id(ReqId) ->
  
negative.code: test(N) ->
      quickcheck(numtests(N, prop_basic_get())).
  
  expect(Object,History,N,R) ->
      case expect(History,N,R,0,0) of
          ok  -> {ok, Object};
          Err -> {error, Err}
      end.
  
  expect([],N,R,NotFounds,_Oks) ->
      case NotFounds >= N-R+1 of
          true -> notfound;        
  