anchor.diff:         end
         }]}.
   
  +make_test_bucket(Backend, Suffix) ->
  +    try
  +        Backend:backend_eunit_bucket(Suffix)
  +    catch error:undef ->
  +            <<"b", ($0 + Suffix):8>>
  +    end.
  +
  +make_test_key(Backend, Suffix) ->
  +    try
  +        Backend:backend_eunit_key(Suffix)
  +    catch error:undef ->
  +            <<"k", ($0 + Suffix):8>>
  +    end.
  +
  +make_bs_and_ks(Backend) ->
  +    {make_test_bucket(Backend, 1),
  +     make_test_bucket(Backend, 2),
  +     make_test_key(Backend, 2),
  +     make_test_key(Backend, 2)}.
  +
   basic_store_and_fetch({Backend, State}) ->
  +    {B1, B2, K1, K2} = make_bs_and_ks(Backend),
       {"basic store and fetch test",
        fun() ->
                ?assertMatch({ok, _},
  -                          Backend:put(<<"b1">>, <<"k1">>, [], <<"v1">>, State)),
  +                          Backend:put(B1, K1, [], <<"v1">>, State)),
                ?assertMatch({ok, _},
  -                          Backend:put(<<"b2">>, <<"k2">>, [], <<"v2">>, State)),
  +                          Backend:put(B2, K2, [], <<"v2">>, State)),
                ?assertMatch({ok,<<"v2">>, _},
  -                          Backend:get(<<"b2">>, <<"k2">>, State)),
  +                          Backend:get(B2, K2, State)),
                ?assertMatch({error, not_found, _},
  -                          Backend:get(<<"b1">>, <<"k3">>, State))
  +                          Backend:get(B1, <<"k3">>, State))
        end
       }.
   
   fold_buckets({Backend, State}) ->
  +    {B1, B2, _K1, _K2} = make_bs_and_ks(Backend),
       {"bucket folding test",
        fun() ->
                FoldBucketsFun =
  
positive.code:     }.
  
  fold_keys({Backend, State}) ->
      {"key folding test",
       fun() ->
               FoldKeysFun =
  
negative.code:                                                     State),
                                lists:sort(Keys1)
                            end),
               ?assertEqual({ok, [K1]},
                            Backend:fold_keys(FoldKeysFun1,
                                              [],
                                              [{bucket, B1}],
                                              State)),
               ?assertEqual({ok, [K2]},
                            Backend:fold_keys(FoldKeysFun1,
                                              [],
                                              [{bucket, B2}],
                                              State)),
               ?assertEqual({ok, [K1]},
                            Backend:fold_keys(FoldKeysFun2, [], [], State)),
               ?assertEqual({ok, [K1]},
                            Backend:fold_keys(FoldKeysFun2,
                                              [],
                                              [{bucket, B1}],
                                              State)),
               ?assertEqual({ok, [K2]},
                            Backend:fold_keys(FoldKeysFun3, [], [], State)),
               ?assertEqual({ok, []},
                            Backend:fold_keys(FoldKeysFun3,
                                              [],
                                              [{bucket, B1}],
                                              State))
       end
      }.
  
  delete_object({Backend, State}) ->
      {_B1, B2, _K1, K2} = make_bs_and_ks(Backend),
      {"object deletion test",
       fun() ->
               ?assertMatch({ok, _}, Backend:delete(B2, K2, [], State)),
               ?assertMatch({error, not_found, _},
                            Backend:get(B2, K2, State))
       end
      }.
  
  fold_objects({Backend, State}) ->
      {B1, _B2, K1, _K2} = make_bs_and_ks(Backend),
      B3 = make_test_bucket(Backend, 3),
      K3 = make_test_key(Backend, 3),
      ObjFilter = fun(Os) -> [if is_binary(X) -> {BK, X};
                                 true         -> {BK, riak_object:get_value(X)}
                              end || {BK, X} <- Os]
                  end,
      {"object folding test",
       fun() ->
               FoldKeysFun =
  