anchor.diff:  
       no_repeat = maps:get(filesync_repeat_interval,
                            logger_disk_log_h:info(?MODULE)),
  +    %% The following timer is to make sure the time from last log
  +    %% ("first") to next ("second") is long enough, so the a flush is
  +    %% triggered by the idle timeout between "fourth" and "fifth".
  +    timer:sleep(?IDLE_DETECT_TIME_MSEC*2),
   
       start_tracer([{disk_log,blog,2},
  -                  {disk_log,sync,1}],
  -                 [{disk_log,blog,<<"fourth\n">>},
  -                  {disk_log,blog,<<"fifth\n">>},
  -                  {disk_log,sync}]),
  -
  -    logger:notice("fourth", ?domain),
  +                  {logger_disk_log_h,disk_log_sync,2}],
  +                 [{disk_log,blog,<<"second\n">>},
  +                  {logger_disk_log_h,disk_log_sync},
  +                  {disk_log,blog,<<"third\n">>},
  +                  {logger_disk_log_h,disk_log_sync}]),
  +
  +    logger:notice("second", ?domain),
       timer:sleep(?IDLE_DETECT_TIME_MSEC*2),
  -    logger:notice("fifth", ?domain),
  +    logger:notice("third", ?domain),
       %% wait for automatic disk_log_sync
       check_tracer(?IDLE_DETECT_TIME_MSEC*2),
   
  -    try_read_file(Log, {ok,<<"first\nsecond\nthird\nfourth\nfifth\n">>}, 1000),
  +    try_read_file(Log, {ok,<<"first\nsecond\nthird\n">>}, 1000),
       
       %% switch repeated disk_log_sync on and verify that the looping works
       SyncInt = 1000,
  
positive.code:     ok.
  
  tpl([{M,F,A}|Trace]) ->
      {ok,Match} = dbg:tpl(M,F,A,[]),
      case lists:keyfind(matched,1,Match) of
          {_,_,1} ->
              ok;
  
negative.code: tpl([]) ->
      ok.
  
  tracer({trace,_,call,{logger_disk_log_h,handle_cast,[Op|_]},Caller},
         {Pid,[{Mod,Func,Op}|Expected]}) ->
      maybe_tracer_done(Pid,Expected,{Mod,Func,Op},Caller);
  tracer({trace,_,call,{Mod=disk_log,Func=blog,[_,Data]},Caller}, {Pid,[{Mod,Func,Data}|Expected]}) ->
      maybe_tracer_done(Pid,Expected,{Mod,Func,Data},Caller);
  tracer({trace,_,call,{Mod,Func,_},Caller}, {Pid,[{Mod,Func}|Expected]}) ->
      maybe_tracer_done(Pid,Expected,{Mod,Func},Caller);
  tracer({trace,_,call,Call,Caller}, {Pid,Expected}) ->
      ct:log("Tracer got unexpected: ~p~nCaller: ~p~nExpected: ~p~n",[Call,Caller,Expected]),
      Pid ! {tracer_got_unexpected,Call,Expected},
      {Pid,Expected}.
  
  maybe_tracer_done(Pid,[],Got,Caller) ->
      ct:log("Tracer got: ~p~nCaller: ~p~n",[Got,Caller]),
      Pid ! tracer_done;
  maybe_tracer_done(Pid,Expected,Got,Caller) ->
      ct:log("Tracer got: ~p~nCaller: ~p~n",[Got,Caller]),
      {Pid,Expected}.
  
  check_tracer(T) ->
  