anchor.diff:             [?_assertEqual(true,
                             backend_eqc:test(?MODULE,
                                              false,
  -                                           [{data_root,
  +                                           [{fs2_backend_data_root,
                                                "test/fs-backend"}]))]}
            ]}]}]}.
   
  
positive.code:             {ok, BucketFolder()}
      end.
  
  %% %% @doc Fold over all the keys for one or all buckets.
  %% -spec fold_keys(riak_kv_backend:fold_keys_fun(),
  %%                 any(),
  %%                 [{atom(), term()}],
  %%                 state()) -> {ok, term()} | {async, fun()} | {error, term()}.
  %% fold_keys(FoldKeysFun, Acc, Opts, #state{opts=BitcaskOpts,
  %%                                          data_dir=DataFile,
  %%                                          ref=Ref,
  %%                                          root=DataRoot}) ->
  %%     Bucket =  proplists:get_value(bucket, Opts),
  %%     FoldFun = fold_keys_fun(FoldKeysFun, Bucket),
  %%     case lists:member(async_fold, Opts) of
  %%         true ->
  %%             ReadOpts = set_mode(read_only, BitcaskOpts),
  %%             KeyFolder =
  %%                 fun() ->
  %%                         case bitcask:open(filename:join(DataRoot, DataFile),
  %%                                           ReadOpts) of
  %%                             Ref1 when is_reference(Ref1) ->
  %%                                 try
  %%                                     bitcask:fold_keys(Ref1, FoldFun, Acc)
  %%                                 after
  %%                                     bitcask:close(Ref1)
  %%                                 end;
  %%                             {error, Reason} ->
  %%                                 {error, Reason}
  %%                         end
  %%                 end,
  %%             {async, KeyFolder};
  %%         false ->
  %%             FoldResult = bitcask:fold_keys(Ref, FoldFun, Acc),
  %%             case FoldResult of
  %%                 {error, _} ->
  %%                     FoldResult;
  %%                 _ ->
  %%                     {ok, FoldResult}
  %%             end
  %%     end.
  
  %% %% @doc Fold over all the objects for one or all buckets.
  %% -spec fold_objects(riak_kv_backend:fold_objects_fun(),
  %%                    any(),
  %%                    [{atom(), term()}],
  %%                    state()) -> {ok, any()} | {async, fun()} | {error, term()}.
  %% fold_objects(FoldObjectsFun, Acc, Opts, #state{opts=BitcaskOpts,
  %%                                                data_dir=DataFile,
  %%                                                ref=Ref,
  %%                                                root=DataRoot}) ->
  %%     Bucket =  proplists:get_value(bucket, Opts),
  %%     FoldFun = fold_objects_fun(FoldObjectsFun, Bucket),
  %%     case lists:member(async_fold, Opts) of
  %%         true ->
  %%             ReadOpts = set_mode(read_only, BitcaskOpts),
  %%             ObjectFolder =
  %%                 fun() ->
  %%                         case bitcask:open(filename:join(DataRoot, DataFile),
  %%                                           ReadOpts) of
  %%                             Ref1 when is_reference(Ref1) ->
  %%                                 try
  %%                                     bitcask:fold(Ref1, FoldFun, Acc)
  %%                                 after
  %%                                     bitcask:close(Ref1)
  %%                                 end;
  %%                             {error, Reason} ->
  %%                                 {error, Reason}
  %%                         end
  %%                 end,
  %%             {async, ObjectFolder};
  %%         false ->
  %%             FoldResult = bitcask:fold(Ref, FoldFun, Acc),
  %%             case FoldResult of
  %%                 {error, _} ->
  %%                     FoldResult;
  %%                 _ ->
  %%                     {ok, FoldResult}
  %%             end
  %%     end.
  
  
  
  
  -spec drop(state()) -> {ok, state()} | {error, term(), state()}.
  drop(State) ->
      [file:delete(location(State, BK)) || BK <- ?MODULE:list(State)],
      Cmd = io_lib:format("rm -Rf ~s", [State#state.dir]),
      os:cmd(Cmd),
      {ok, State}.
  
  -spec is_empty(state()) -> boolean().
  is_empty(S) ->
      ?MODULE:list(S) == [].
  
  -spec status(state()) -> [{atom(), term()}].
  status(_S) ->
      [no_status_sorry].
  
  -spec callback(reference(), any(), state()) -> {ok, state()}.
  callback(_Ref, _Term, S) ->
      {ok, S}.
  
negative.code:     Dir = filename:join([ConfigRoot,PartitionName]),
      {filelib:ensure_dir(Dir), #state{dir=Dir}}.
  
  %% @doc Stop the backend
  -spec stop(state()) -> ok.
  stop(_State) -> ok.
  
  