anchor.diff:      hd(lists:filtermap(fun(#xmlElement{name = copyright, content = [Copyright]}) ->
           {true, list_to_binary(Copyright#xmlText.value)};
           (_) -> false
  -   end, Doc#xmlElement.content)).
  +    end, Doc#xmlElement.content)).
   
   %%--------------------------------------------------------------------
   %% @private
  
positive.code:     ct:timetrap({seconds, Timeout + ?STRESS_TIMEOUT_EXTENSION_SECONDS}), % add 10 minutes to let running tests end
  
      AnsList = lists:foldl(fun(Case, Ans) ->
          CaseAns = try
                        NewConfig = try
                                        apply(Suite, init_per_testcase, [Case, Config])
                                    catch
                                        error:undef ->
                                            Config
                                    end,
                        case apply(Suite, Case, [NewConfig]) of
                            {ok, TmpAns} ->
  %%                           TmpAns2 = lists:map(fun(Param) ->
  %%                               PName = Param#parameter.name,
  %%                               Param#parameter{name = concat_atoms(Case, PName)}
  %%                           end, TmpAns),
  %%                           [{ok, TmpAns2} | Ans];
                                [{ok, TmpAns} | Ans];
                            {error, E} ->
                                Message = str_utils:format("Case: ~p, error: ~p", [Case, E]),
                                [{error, Message} | Ans]
                        end
                    catch
                        E1:E2 ->
                            % only init_per_testcase can throw (case has catch inside)
                            ct:print("Case: ~p, init_per_testcase error: ~p:~p", [Case, E1, E2]),
                            Message2 = str_utils:format("Case: ~p, init_per_testcase error: ~p:~p", [Case, E1, E2]),
                            [{error, Message2} | Ans]
                    end,
          try
              apply(Suite, end_per_testcase, [Case, Config])
          catch
              error:undef ->
                  ok;
              E1_2:E2_2 ->
                  ct:print("Case: ~p, end_per_testcase error: ~p:~p", [Case, E1_2, E2_2])
          end,
          CaseAns
      end, [], Cases),
      lists:reverse(AnsList).
  
  
negative.code:                        TestTime = timer:now_diff(Now, StartTime) div 1000000,
                         TimeLeft = TimeLimit - TestTime,
  
                         [{cases, Cases}] = ets:lookup(?STRESS_ETS_NAME, cases),
                         ZippedFR = lists:zip(FailedReps, Cases),
                         ErrorsHistoryOK = lists:foldl(fun({FR, Case}, Acc) ->
                             CheckAns = check_error(Rep, FR),
                             ets:insert(?STRESS_ETS_NAME, {{history, Case}, {Rep, maps:size(FR), CheckAns}}),
                             case Acc of
                                 permanent_error ->
                                     CheckAns;
                                 _ ->
                                     Acc
                             end
                         end, permanent_error, ZippedFR),
  
                         case (TimeLeft > 0) and (ErrorsHistoryOK =/= permanent_error) of
                             true ->
                                 ct:print("SUITE: ~p~nCASE: ~p~nCONFIG: ~p~nREPEAT: ~p, TEST TIME ~p sek, TIME LEFT ~p sek",
                                     [SuiteName, CaseName, ConfigName, Rep, TestTime, TimeLeft]),
  