anchor.diff:  
   
   setup() ->
  +    Ctx = test_util:start(?MODULE, [couch_log], [{dont_mock, [config]}]),
       {ok, TaskStatusPid} = couch_task_status:start_link(),
       TaskUpdaterPid = spawn(fun() -> loop() end),
  -    {TaskStatusPid, TaskUpdaterPid}.
  -
  -teardown({TaskStatusPid, _}) ->
  +    {TaskStatusPid, TaskUpdaterPid, Ctx}.
  +
  +
  +teardown({TaskStatusPid, _, Ctx})->
       test_util:stop_sync_throw(TaskStatusPid, fun() ->
           couch_task_status:stop()
  -    end, timeout_error, ?TIMEOUT).
  +    end, timeout_error, ?TIMEOUT),
  +    test_util:stop(Ctx).
  +
   
   couch_task_status_test_() ->
       {
  
positive.code:     }.
  
  
  should_register_task({_, Pid}) ->
      ok = call(Pid, add, [{type, replication}, {progress, 0}]),
      ?_assertEqual(1, length(couch_task_status:all())).
  
  should_set_task_startup_time({_, Pid}) ->
      ok = call(Pid, add, [{type, replication}, {progress, 0}]),
      ?_assert(is_integer(get_task_prop(Pid, started_on))).
  
  should_have_update_time_as_startup_before_any_progress({_, Pid}) ->
      ok = call(Pid, add, [{type, replication}, {progress, 0}]),
      StartTime = get_task_prop(Pid, started_on),
      ?_assertEqual(StartTime, get_task_prop(Pid, updated_on)).
  
  should_set_task_type({_, Pid}) ->
      ok = call(Pid, add, [{type, replication}, {progress, 0}]),
      ?_assertEqual(replication, get_task_prop(Pid, type)).
  
  should_not_register_multiple_tasks_for_same_pid({_, Pid}) ->
      ok = call(Pid, add, [{type, replication}, {progress, 0}]),
      ?_assertEqual({add_task_error, already_registered},
                    call(Pid, add, [{type, compaction}, {progress, 0}])).
  
  should_set_task_progress({_, Pid}) ->
      ok = call(Pid, add, [{type, replication}, {progress, 0}]),
      ?_assertEqual(0, get_task_prop(Pid, progress)).
  
  should_update_task_progress({_, Pid}) ->
      ok = call(Pid, add, [{type, replication}, {progress, 0}]),
      call(Pid, update, [{progress, 25}]),
      ?_assertEqual(25, get_task_prop(Pid, progress)).
  
  should_update_time_changes_on_task_progress({_, Pid}) ->
      ?_assert(
          begin
              ok = call(Pid, add, [{type, replication}, {progress, 0}]),
  
negative.code: %%            get_task_prop(Pid, progress)
  %%        end).
  
  should_reset_control_update_frequency({_, Pid, _Ctx}) ->
      ?_assertEqual(87,
          begin
              ok = call(Pid, add, [{type, replication}, {progress, 0}]),
  