anchor.diff:  init(_Id, _Opts) ->
       {ok, #c{n=1}}.
   
  -pre_init_per_suite(Suite, Config, CTHState) ->
  -    {Config, CTHState#c{suite=Suite}}.
  +pre_init_per_suite(Suite, Config, State0) ->
  +    {_, State} = read_known_hosts_diff(State0#c{suite=Suite}),
  +    {Config, State}.
   
   pre_end_per_suite(Suite, Config, State) ->
       ct:pal("BEGIN ~p:end_per_suite(...)", [Suite]),
  -     {Config, State}.
  +    {Config, State}.
   
   
  -pre_init_per_group(_Suite, Group, Config ,State) ->
  -     {Config, State#c{groups = (State#c.groups ++ [Group])}}.
  +pre_init_per_group(Suite, Group, Config, State0) ->
  +    {Diff, State} = read_known_hosts_diff(State0),
  +    ct:pal("~sBEGIN ~p:init_per_group(~p,...)", [log_diff(Diff),Suite,Group]),
  +    {Config, State#c{groups = (State#c.groups ++ [Group])}}.
   
  -pre_end_per_group(Suite, Group, Config, State) ->
  -    ct:pal("BEGIN ~p:end_per_group(~p,...)", [Suite,Group]),
  +post_init_per_group(Suite, Group, _Config, Return, State0) ->
  +    {Diff, State} = read_known_hosts_diff(State0),
  +    ct:pal("~sEND ~p:init_per_group(~p,...)", [log_diff(Diff),Suite,Group]),
  +    {Return, State}.
  +
  +pre_end_per_group(Suite, Group, Config, State0) ->
  +    {Diff, State} = read_known_hosts_diff(State0),
  +    ct:pal("~sBEGIN ~p:end_per_group(~p,...)", [log_diff(Diff), Suite, Group]),
       {Config, State}.
   
  -post_end_per_group(_Suite, Group, _Config, Return, State) ->
  -     {Return, State#c{groups = lists:reverse(lists:reverse(State#c.groups)--[Group])}}.
  +post_end_per_group(Suite, Group, _Config, Return, State0) ->
  +    {Diff, State} = read_known_hosts_diff(State0),
  +    ct:pal("~sEND ~p:end_per_group(~p,...)", [log_diff(Diff),Suite,Group]),
  +    {Return, State#c{groups = lists:reverse(lists:reverse(State#c.groups)--[Group])}}.
   
   
  -pre_init_per_testcase(SuiteName, Config, CTHState) ->
  -    ct:pal("########## ~p ~p ~s ~p~n", [CTHState#c.suite, CTHState#c.n, groups(Config), SuiteName]),
  -    {Config, CTHState#c{n = CTHState#c.n + 1}}.
  +pre_init_per_testcase(SuiteName, _TC, Config, State0) ->
  +    {Diff, State} = read_known_hosts_diff(State0),
  +    ct:pal("~s########## ~p ~p ~s ~p", [log_diff(Diff), State0#c.suite, State0#c.n, groups(Config), SuiteName]),
  +    {Config, State#c{n = State#c.n + 1}}.
   
  -pre_end_per_testcase(Suite,TC,Config,State) ->
  -    ct:pal("BEGIN ~p:end_per_testcase(~p,...)", [Suite,TC]),
  +post_init_per_testcase(SuiteName, TestcaseName, _Config, Return, State0) ->
  +    {Diff, State} = read_known_hosts_diff(State0),
  +    ct:pal("~send ~p:init_per_testcase(~p,...)", [log_diff(Diff), SuiteName, TestcaseName]),
  +    {Return, State}.
  +
  +pre_end_per_testcase(Suite, TC, Config, State0) ->
  +    {Diff, State} = read_known_hosts_diff(State0),
  +    ct:pal("~sBEGIN ~p:end_per_testcase(~p,...)", [log_diff(Diff), Suite, TC]),
       {Config, State}.
  +
  +post_end_per_testcase(SuiteName, TC, _Config, Return, State0) ->
  +    {Diff, State} = read_known_hosts_diff(State0),
  +    ct:pal("~sEND ~p:end_per_testcase(~p,...)", [log_diff(Diff), SuiteName, TC]),
  +    {Return, State}.
  +
  +
   
   
   groups(Config) ->
  
positive.code:          pre_init_per_suite/3,
           pre_end_per_suite/3,
           pre_init_per_group/4,
           pre_end_per_group/4,
           post_end_per_group/5,
           pre_init_per_testcase/3,
           pre_end_per_testcase/4
          ]).
  
  -record(c, {
            suite, % suite name
            groups = [], % Group path in reversed order
            n % test case number
  
negative.code:              is_list(L),
               {name,Name} <- L].
      
  
  
  read_known_hosts_diff(S = #c{known_hosts_file_name = File,
                               known_hosts_last_contents = Bin0}) ->
      {ok,  <<Bin0:(size(Bin0))/binary, Diff/binary>> = Bin} = file:read_file(File),
      {Diff, S#c{known_hosts_last_contents = Bin}}.
  
  log_diff(<<>>) -> "";
  log_diff(Bin) -> io_lib:format("~n++++ ~p~n",[Bin]).
      
  