anchor.diff:                   end,
                FoldKeysFun2 =
                    fun(Bucket, Key, Acc) ->
  -                         case Bucket =:= <<"b1">> of
  +                         case Bucket =:= B1 of
                                true ->
                                    [Key | Acc];
                                false ->
  
positive.code:                          end
                   end,
  
               ?assertEqual([{<<"b1">>, <<"k1">>}, {<<"b2">>, <<"k2">>}],
                            begin
                                {ok, Keys1} =
                                    Backend:fold_keys(FoldKeysFun,
  
negative.code:        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)),
               ?assertMatch({ok, _},
                            Backend:put(B2, K2, [], <<"v2">>, State)),
               ?assertMatch({ok,<<"v2">>, _},
                            Backend:get(B2, K2, State)),
               ?assertMatch({error, not_found, _},
                            Backend:get(B1, <<"k3">>, State))
       end
      }.
  
  fold_buckets({Backend, State}) ->
      {B1, B2, _K1, _K2} = make_bs_and_ks(Backend),
      {"bucket folding test",
       fun() ->
               FoldBucketsFun =
  