anchor.diff:  include_app_phase(start, folsom) -> false;
   include_app_phase(_Phase, _App) -> true.
   
  +%% Make sure an application and all of its dependent applications are started.
  +%% Similar to application:ensure_all_started/1 available in R16B02.
  +-spec start_app_and_deps(Application::atom(), [atom()]) -> {ok, [atom()]} | {error, term()}.
  +start_app_and_deps(Application, Started) ->
  +    case lists:member(Application, Started) of
  +        true ->
  +            {ok, Started};
  +        false ->
  +            case application:start(Application) of
  +                ok ->
  +                    {ok, [Application|Started]};
  +                {error, {already_started, Application}} ->
  +                    {ok, Started};
  +                {error, {not_started, Dep}} ->
  +                    case start_app_and_deps(Dep, Started) of
  +                        {ok, NStarted} ->
  +                            start_app_and_deps(Application, NStarted);
  +                        Error ->
  +                            Error
  +                    end;
  +                {error, Reason} ->
  +                    [application:stop(App) || App <- Started],
  +                    {error, Reason}
  +            end
  +    end.
  +
   
   -endif. % TEST
  
positive.code:     net_kernel:start([TestNode, longnames]),
  
      %% Start dependent applications
      do_dep_apps(start, Deps),
  
      %% Wait for KV to be ready
      riak_core:wait_for_application(riak_kv),
      riak_core:wait_for_service(riak_kv),
      ok.
  
  %% @doc Performs generic, riak_kv-specific and test-specific cleanup
  %% when used within a test fixture. This includes stopping dependent
  
negative.code:            (_) -> ok
          end,
  
      [sasl, Silencer, runtime_tools, erlang_js, mochiweb, webmachine,
       sidejob, poolboy, basho_stats, bitcask, lager, folsom, protobuffs,
       eleveldb, riak_core, riak_pipe, riak_api, riak_dt, riak_pb, riak_kv,
       DefaultSetupFun, Extra].
  
  
  %% @doc Runs the application-lifecycle phase across all of the given
  %% applications and functions.
  %% @see dep_apps/2
  -spec do_dep_apps(load | start | stop, [ atom() | fun() ]) -> [ any() ].
  do_dep_apps(start, Apps) ->
      lists:foldl(fun(A, Acc) when is_atom(A) ->
                          case include_app_phase(start, A) of
                              true ->
                                  {ok, Started} = start_app_and_deps(A, Acc),
                                  Started;
                              _ ->
                                  Acc
                          end;
                      (F, Acc) ->
                         F(start),
                         Acc
                 end, [], Apps);
  do_dep_apps(LoadStop, Apps) ->
      lists:map(fun(A) when is_atom(A) ->
                        case include_app_phase(LoadStop, A) of
                            true ->
                                application:LoadStop(A);
                            _ ->
                                ok
                        end;
                   (F) ->
                        F(LoadStop)
                end, Apps).
  
  %% @doc Determines whether a given application should be modified in
  