PrintStreamOutput.java

  1. package org.jbehave.core.reporters;

  3. import static org.apache.commons.lang3.StringUtils.substringBetween;
  4. import static org.jbehave.core.steps.StepCreator.PARAMETER_TABLE_END;
  5. import static org.jbehave.core.steps.StepCreator.PARAMETER_TABLE_START;
  6. import static org.jbehave.core.steps.StepCreator.PARAMETER_VALUE_END;
  7. import static org.jbehave.core.steps.StepCreator.PARAMETER_VALUE_NEWLINE;
  8. import static org.jbehave.core.steps.StepCreator.PARAMETER_VALUE_START;
  9. import static org.jbehave.core.steps.StepCreator.PARAMETER_VERBATIM_END;
  10. import static org.jbehave.core.steps.StepCreator.PARAMETER_VERBATIM_START;

  12. import java.io.ByteArrayOutputStream;
  13. import java.io.OutputStream;
  14. import java.io.PrintStream;
  15. import java.text.MessageFormat;
  16. import java.text.SimpleDateFormat;
  17. import java.util.Date;
  18. import java.util.List;
  19. import java.util.Locale;
  20. import java.util.Map;
  21. import java.util.Properties;
  22. import java.util.stream.Stream;

  24. import org.apache.commons.lang3.StringUtils;
  25. import org.apache.commons.lang3.builder.ToStringBuilder;
  26. import org.apache.commons.lang3.builder.ToStringStyle;
  27. import org.apache.commons.text.CaseUtils;
  28. import org.jbehave.core.annotations.AfterScenario;
  29. import org.jbehave.core.annotations.Scope;
  30. import org.jbehave.core.configuration.Keywords;
  31. import org.jbehave.core.embedder.MetaFilter;
  32. import org.jbehave.core.failures.KnownFailure;
  33. import org.jbehave.core.failures.UUIDExceptionWrapper;
  34. import org.jbehave.core.model.ExamplesTable;
  35. import org.jbehave.core.model.GivenStories;
  36. import org.jbehave.core.model.GivenStory;
  37. import org.jbehave.core.model.Lifecycle;
  38. import org.jbehave.core.model.Meta;
  39. import org.jbehave.core.model.Narrative;
  40. import org.jbehave.core.model.OutcomesTable;
  41. import org.jbehave.core.model.OutcomesTable.Outcome;
  42. import org.jbehave.core.model.Scenario;
  43. import org.jbehave.core.model.Step;
  44. import org.jbehave.core.model.Story;
  45. import org.jbehave.core.model.StoryDuration;
  46. import org.jbehave.core.model.Verbatim;
  47. import org.jbehave.core.steps.StepCollector.Stage;
  48. import org.jbehave.core.steps.StepCreator.PendingStep;
  49. import org.jbehave.core.steps.Timing;

  51. /**
  52.  * <p>
  53.  * Abstract story reporter that outputs to a PrintStream.
  54.  * </p>
  55.  * <p>
  56.  * The output of the reported event is configurable via:
  57.  * <ul>
  58.  * <li>custom output patterns, providing only the patterns that differ from
  59.  * default</li>
  60.  * <li>keywords localised for different languages, providing the formatOutcome Locale</li>
  61.  * <li>flag to report failure trace</li>
  62.  * </ul>
  63.  * </p>
  64.  * <p>
  65.  * Let's look at example of providing custom output patterns, e.g. for the
  66.  * failed event. <br/>
  67.  * we'd need to provide the custom pattern, say we want to have something like
  68.  * "(step being executed) <<< FAILED", keyed on the method name:
  69.  * 
  70.  * <pre>
  71.  * Properties patterns = new Properties();
  72.  * patterns.setProperty(&quot;failed&quot;, &quot;{0} &lt;&lt;&lt; {1}&quot;);
  73.  * </pre>
  74.  * 
  75.  * The pattern is by default processed and formatted by the
  76.  * {@link MessageFormat}. Both the
  77.  * {@link #format(String key, String defaultPattern, Object... args)} and
  78.  * {@link #lookupPattern(String key, String defaultPattern)} methods are
  79.  * override-able and a different formatter or pattern lookup can be used by
  80.  * subclasses.
  81.  * </p>
  82.  * <p>
  83.  * If the keyword "FAILED" (or any other keyword used by the reporter) needs to
  84.  * be expressed in a different language, all we need to do is to provide an
  85.  * instance of {@link org.jbehave.core.i18n.LocalizedKeywords} using the
  86.  * appropriate {@link Locale}, e.g.
  87.  * 
  88.  * <pre>
  89.  * Keywords keywords = new LocalizedKeywords(new Locale(&quot;it&quot;));
  90.  * </pre>
  91.  * 
  92.  * </p>
  93.  */
  94. public abstract class PrintStreamOutput extends NullStoryReporter {

  96.     private static final String EMPTY = "";
  97.     public static final String NL = "\n";

  99.     public enum Format {
  100.         TXT {
  101.             @Override
  102.             public Object escapeValue(Object object) {
  103.                 return object;
  104.             }
  105.         },
  106.         HTML {
  107.             @Override
  108.             public Object escapeValue(Object object) {
  109.                 return EscapeMode.HTML.escapeString(asString(object));
  110.             }
  111.         },
  112.         XML {
  113.             @Override
  114.             public Object escapeValue(Object object) {
  115.                 return EscapeMode.XML.escapeString(asString(object));
  116.             }
  117.         },
  118.         JSON {
  119.             @Override
  120.             public Object escapeValue(Object object) {
  121.                 return EscapeMode.JSON.escapeString(asString(object));
  122.             }
  123.         };

  125.         public abstract Object escapeValue(Object object);

  127.         private static String asString(Object object) {
  128.             return object != null ? object.toString() : EMPTY;
  129.         }
  130.     }

  132.     private final Format format;
  133.     private final PrintStream output;
  134.     private final Properties outputPatterns;
  135.     private final Keywords keywords;
  136.     private ThreadLocal<Boolean> reportFailureTrace = new ThreadLocal<>();
  137.     private ThreadLocal<Boolean> compressFailureTrace = new ThreadLocal<>();
  138.     private ThreadLocal<Throwable> cause = new ThreadLocal<>();
  139.     private ThreadLocal<Boolean> dryRun = ThreadLocal.withInitial(() -> false);

  141.     protected PrintStreamOutput(Format format, PrintStream output, Properties defaultPatterns,
  142.             Properties outputPatterns, Keywords keywords) {
  143.         this(format, output, mergePatterns(defaultPatterns, outputPatterns), keywords, false,
  144.                 false);
  145.     }

  147.     protected PrintStreamOutput(Format format, PrintStream output, Properties defaultPatterns,
  148.             Properties outputPatterns, Keywords keywords, boolean reportFailureTrace, boolean compressFailureTrace) {
  149.         this(format, output, mergePatterns(defaultPatterns, outputPatterns), keywords, reportFailureTrace,
  150.                 compressFailureTrace);
  151.     }

  153.     protected PrintStreamOutput(Format format, PrintStream output, Properties outputPatterns, Keywords keywords,
  154.             boolean reportFailureTrace, boolean compressFailureTrace) {
  155.         this.format = format;
  156.         this.output = output;
  157.         this.outputPatterns = outputPatterns;
  158.         this.keywords = keywords;
  159.         doReportFailureTrace(reportFailureTrace);
  160.         doCompressFailureTrace(compressFailureTrace);
  161.     }

  163.     private static Properties mergePatterns(Properties defaultPatterns, Properties outputPatterns) {
  164.         Properties patterns = new Properties();
  165.         patterns.putAll(defaultPatterns);
  166.         // override any default pattern
  167.         patterns.putAll(outputPatterns);
  168.         return patterns;
  169.     }

  171.     @Override
  172.     public void beforeStep(Step step) {
  173.         print(format("beforeStep", "{0}\n", step.getStepAsString()));
  174.     }

  176.     @Override
  177.     public void successful(String step) {
  178.         print(format("successful", "{0}\n", step));
  179.     }

  181.     @Override
  182.     public void ignorable(String step) {
  183.         print(format("ignorable", "{0}\n", step));
  184.     }

  186.     @Override
  187.     public void comment(String step) {
  188.         print(format("comment", "{0}\n", step));
  189.     }

  191.     @Override
  192.     public void pending(PendingStep step) {
  193.         print(format("pending", "{0} ({1})\n({2})\n", step.stepAsString(), keywords.pending(),
  194.                 step.getPendingMethod()));
  195.     }

  197.     @Override
  198.     public void notPerformed(String step) {
  199.         print(format("notPerformed", "{0} ({1})\n", step, keywords.notPerformed()));
  200.     }

  202.     @Override
  203.     public void failed(String step, Throwable storyFailure) {
  204.         // storyFailure be used if a subclass has rewritten the "failed" pattern
  205.         // to have a {3} as WebDriverHtmlOutput (jbehave-web) does.
  206.         if (storyFailure instanceof UUIDExceptionWrapper) {
  207.             this.cause.set(storyFailure.getCause());
  208.             print(format("failed", "{0} ({1})\n({2})\n", step, keywords.failed(), storyFailure.getCause(),
  209.                     ((UUIDExceptionWrapper) storyFailure).getUUID()));
  210.         } else {
  211.             throw new ClassCastException(storyFailure + " should be an instance of UUIDExceptionWrapper");
  212.         }
  213.     }

  215.     @Override
  216.     public void failedOutcomes(String step, OutcomesTable table) {
  217.         failed(step, table.failureCause());
  218.         printOutcomesTable(table);
  219.     }

  221.     private void printOutcomesTable(OutcomesTable table) {
  222.         print(format("outcomesTableStart", NL));
  223.         List<Outcome<?>> rows = table.getOutcomes();
  224.         print(format("outcomesTableHeadStart", "|"));
  225.         for (String field : table.getOutcomeFields()) {
  226.             print(format("outcomesTableHeadCell", "{0}|", field));
  227.         }
  228.         print(format("outcomesTableHeadEnd", NL));
  229.         print(format("outcomesTableBodyStart", EMPTY));
  230.         for (Outcome<?> outcome : rows) {
  231.             print(format("outcomesTableRowStart", "|", outcome.isVerified() ? "verified" : "notVerified"));
  232.             print(format("outcomesTableCell", "{0}|", outcome.getDescription()));
  233.             print(format("outcomesTableCell", "{0}|", renderOutcomeValue(outcome.getValue(), table)));
  234.             print(format("outcomesTableCell", "{0}|", outcome.getMatcher()));
  235.             print(format("outcomesTableCell", "{0}|", (outcome.isVerified() ? keywords.yes() : keywords.no())));
  236.             print(format("outcomesTableRowEnd", NL));
  237.         }
  238.         print(format("outcomesTableBodyEnd", NL));
  239.         print(format("outcomesTableEnd", NL));
  240.     }

  242.     private Object renderOutcomeValue(Object value, OutcomesTable outcomesTable) {
  243.         if (value instanceof Date) {
  244.             return new SimpleDateFormat(outcomesTable.getFormat(Date.class)).format(value);
  245.         } else {
  246.             return value;
  247.         }
  248.     }

  250.     @Override
  251.     public void storyExcluded(Story story, String filter) {
  252.         print(format("filter", "{0}\n", filter));
  253.     }

  255.     @Override
  256.     public void storyCancelled(Story story, StoryDuration storyDuration) {
  257.         print(format("storyCancelled", "{0}: {1} ({2} s)\n", keywords.storyCancelled(), keywords.duration(),
  258.                 storyDuration.getDurationInSecs()));
  259.     }

  261.     @Override
  262.     public void beforeStory(Story story, boolean givenStory) {
  263.         print(format("beforeStory", "{0}\n{1}\n({2})\n", story.getId(), story.getDescription().asString(),
  264.                 story.getPath()));
  265.         if (dryRun.get()) {
  266.             print(format("dryRun", "{0}\n", keywords.dryRun()));
  267.         }
  268.         printMeta(story.getMeta());
  269.     }

  271.     @Override
  272.     public void beforeScenarios() {
  273.         print(format("beforeScenarios", ""));
  274.     }

  276.     @Override
  277.     public void afterScenarios() {
  278.         print(format("afterScenarios", ""));
  279.     }

  281.     @Override
  282.     public void narrative(Narrative narrative) {
  283.         if (!narrative.isEmpty()) {
  284.             if (!narrative.isAlternative()) {
  285.                 print(format("narrative", "{0}\n{1} {2}\n{3} {4}\n{5} {6}\n", keywords.narrative(),
  286.                         keywords.inOrderTo(), narrative.inOrderTo(), keywords.asA(), narrative.asA(),
  287.                         keywords.iWantTo(), narrative.iWantTo()));
  288.             } else {
  289.                 print(format("narrative", "{0}\n{1} {2}\n{3} {4}\n{5} {6}\n", keywords.narrative(), keywords.asA(),
  290.                         narrative.asA(), keywords.iWantTo(), narrative.iWantTo(), keywords.soThat(),
  291.                         narrative.soThat()));
  292.             }
  293.         }
  294.     }

  296.     @Override
  297.     public void lifecycle(Lifecycle lifecycle) {
  298.         if (!lifecycle.isEmpty()) {
  299.             print(format("lifecycleStart", "{0}\n", keywords.lifecycle()));
  300.             ExamplesTable lifecycleExamplesTable = lifecycle.getExamplesTable();
  301.             if (!lifecycleExamplesTable.isEmpty()) {
  302.                 print(formatTable(lifecycleExamplesTable));
  303.             }
  304.             if (lifecycle.hasBeforeSteps()) {
  305.                 print(format("lifecycleBeforeStart", "{0}\n", keywords.before()));
  306.                 for (Scope scope : lifecycle.getScopes()) {
  307.                     printWithScope(lifecycle.getBeforeSteps(scope), scope);
  308.                 }
  309.                 print(format("lifecycleBeforeEnd", NL));
  310.             }
  311.             if (lifecycle.hasAfterSteps()) {
  312.                 print(format("lifecycleAfterStart", "{0}\n", keywords.after()));
  313.                 for (Scope scope : lifecycle.getScopes()) {
  314.                     printOutcomes(lifecycle, scope);
  315.                 }
  316.                 print(format("lifecycleAfterEnd", NL));
  317.             }
  318.             print(format("lifecycleEnd", NL));
  319.         }
  320.     }

  322.     private void printOutcomes(Lifecycle lifecycle, Scope scope) {
  323.         for (AfterScenario.Outcome outcome : lifecycle.getOutcomes()) {
  324.             List<String> afterSteps = lifecycle.getAfterSteps(scope, outcome);
  325.             if (!afterSteps.isEmpty()) {
  326.                 print(format("lifecycleAfterScopeStart", "{0} {1}\n", keywords.scope(), formatScope(scope)));
  327.                 print(format("lifecycleOutcomeStart", "{0} {1}\n", keywords.outcome(), formatOutcome(outcome)));
  328.                 MetaFilter metaFilter = lifecycle.getMetaFilter(outcome);
  329.                 if (!metaFilter.isEmpty()) {
  330.                     print(format("lifecycleMetaFilter", "{0} {1}\n", keywords.metaFilter(), metaFilter.asString()));
  331.                 }
  332.                 printLifecycleSteps(afterSteps);
  333.                 print(format("lifecycleOutcomeEnd", "\n"));
  334.                 print(format("lifecycleAfterScopeEnd", "\n"));
  335.             }
  336.         }
  337.     }

  339.     private void printWithScope(List<String> steps, Scope scope) {
  340.         if (!steps.isEmpty()) {
  341.             print(format("lifecycleBeforeScopeStart", "{0} {1}\n", keywords.scope(), formatScope(scope)));
  342.             printLifecycleSteps(steps);
  343.             print(format("lifecycleBeforeScopeEnd", "\n"));
  344.         }
  345.     }

  347.     private String formatScope(Scope scope) {
  348.         switch (scope) {
  349.             case SCENARIO: return keywords.scopeScenario();
  350.             case STORY: return keywords.scopeStory();
  351.             default: return scope.name();
  352.         }
  353.     }

  355.     private String formatOutcome(AfterScenario.Outcome outcome) {
  356.         switch (outcome) {
  357.             case ANY:
  358.                 return keywords.outcomeAny();
  359.             case SUCCESS:
  360.                 return keywords.outcomeSuccess();
  361.             case FAILURE:
  362.                 return keywords.outcomeFailure();
  363.             default:
  364.                 return outcome.name();
  365.         }
  366.     }

  368.     private void printLifecycleSteps(List<String> steps) {
  369.         for (String step : steps) {
  370.             print(format("lifecycleStep", "{0}\n", step));
  371.         }
  372.     }

  374.     private void printMeta(Meta meta) {
  375.         if (!meta.isEmpty()) {
  376.             print(format("metaStart", "{0}\n", keywords.meta()));
  377.             for (String name : meta.getPropertyNames()) {
  378.                 print(format("metaProperty", "{0}{1} {2}", keywords.metaProperty(), name, meta.getProperty(name)));
  379.             }
  380.             print(format("metaEnd", NL));
  381.         }
  382.     }

  384.     @Override
  385.     public void beforeScenarioSteps(Stage stage, Lifecycle.ExecutionType type) {
  386.         printScenarioSteps("before", stage, type);
  387.     }

  389.     @Override
  390.     public void afterScenarioSteps(Stage stage, Lifecycle.ExecutionType type) {
  391.         printScenarioSteps("after", stage, type);
  392.     }

  394.     private void printScenarioSteps(String stepsStage, Stage stage, Lifecycle.ExecutionType type) {
  395.         printSteps(stepsStage, "Scenario", stage, type);
  396.     }

  398.     @Override
  399.     public void beforeComposedSteps() {
  400.         print(format("beforeComposedSteps", ""));
  401.     }

  403.     @Override
  404.     public void afterComposedSteps() {
  405.         print(format("afterComposedSteps", ""));
  406.     }

  408.     @Override
  409.     public void beforeStoriesSteps(Stage stage) {
  410.         printStoriesSteps("before", stage);
  411.     }

  413.     @Override
  414.     public void afterStoriesSteps(Stage stage) {
  415.         printStoriesSteps("after", stage);
  416.     }

  418.     private void printStoriesSteps(String stepsStage, Stage stage) {
  419.         printSteps(stepsStage, "Stories", stage, null);
  420.     }

  422.     @Override
  423.     public void beforeStorySteps(Stage stage, Lifecycle.ExecutionType type) {
  424.         printStorySteps("before", stage, type);
  425.     }

  427.     @Override
  428.     public void afterStorySteps(Stage stage, Lifecycle.ExecutionType type) {
  429.         printStorySteps("after", stage, type);
  430.     }

  432.     private void printStorySteps(String stepsStage, Stage stage, Lifecycle.ExecutionType type) {
  433.         printSteps(stepsStage, "Story", stage, type);
  434.     }

  436.     private void printSteps(String stepsStage, String parent, Stage stage, Lifecycle.ExecutionType type) {
  437.         String stageName = stage != null ? CaseUtils.toCamelCase(stage.name(), true) : EMPTY;
  438.         String typeName = type != null ? CaseUtils.toCamelCase(type.name(), true) : EMPTY;
  439.         print(format(stepsStage + stageName + typeName + parent + "Steps", ""));
  440.     }

  442.     @Override
  443.     public void afterStory(boolean givenOrRestartingStory) {
  444.         print(format("afterStory", NL));
  445.         // take care not to close System.out
  446.         // which is used for ConsoleOutput
  447.         if (!givenOrRestartingStory && output != System.out) {
  448.             output.close();
  449.         }
  450.     }

  452.     @Override
  453.     public void beforeGivenStories() {
  454.         print(format("beforeGivenStories", ""));
  455.     }

  457.     @Override
  458.     public void givenStories(GivenStories givenStories) {
  459.         print(format("givenStoriesStart", "{0}\n", keywords.givenStories()));
  460.         for (GivenStory givenStory : givenStories.getStories()) {
  461.             print(format("givenStory", "{0}{1}\n", givenStory.asString(),
  462.                     (givenStory.hasAnchor() ? givenStory.getParameters() : "")));
  463.         }
  464.         print(format("givenStoriesEnd", NL));
  465.     }

  467.     @Override
  468.     public void givenStories(List<String> storyPaths) {
  469.         givenStories(new GivenStories(StringUtils.join(storyPaths, ",")));
  470.     }

  472.     @Override
  473.     public void afterGivenStories() {
  474.         print(format("afterGivenStories", ""));
  475.     }

  477.     @Override
  478.     public void scenarioExcluded(Scenario scenario, String filter) {
  479.         print(format("filter", "{0}\n", filter));
  480.     }

  482.     @Override
  483.     public void beforeScenario(Scenario scenario) {
  484.         cause.set(null);
  485.         print(format("beforeScenario", "{0} {1} {2}\n", scenario.getId(), keywords.scenario(), scenario.getTitle()));
  486.         printMeta(scenario.getMeta());
  487.     }

  489.     @Override
  490.     public void afterScenario(Timing timing) {
  491.         print(format("numericParameter", EMPTY, "start", timing.getStart()));
  492.         print(format("numericParameter", EMPTY, "end", timing.getEnd()));
  493.         if (cause.get() != null && !(cause.get() instanceof KnownFailure) && reportFailureTrace()) {
  494.             print(format("afterScenarioWithFailure", "\n{0}\n",
  495.                     new StackTraceFormatter(compressFailureTrace()).stackTrace(cause.get())));
  496.         } else {
  497.             print(format("afterScenario", NL));
  498.         }
  499.     }

  501.     @Override
  502.     public void beforeExamples(List<String> steps, ExamplesTable table) {
  503.         print(format("beforeExamples", "{0}\n", keywords.examplesTable()));
  504.         print(format("examplesStepsStart", EMPTY));
  505.         for (String step : steps) {
  506.             print(format("examplesStep", "{0}\n", step));
  507.         }
  508.         print(format("examplesStepsEnd", EMPTY));
  509.         print(formatTable(table));
  510.         print(format("exampleScenariosStart", EMPTY));
  511.     }

  513.     @Override
  514.     public void example(Map<String, String> tableRow, int exampleIndex) {
  515.         print(format("example", "\n{0} {1}\n", keywords.examplesTableRow(), tableRow));
  516.         print(output, format("beforeExampleParameters", EMPTY));
  517.         tableRow.entrySet().forEach(
  518.                 cell -> print(output, format("exampleParameter", EMPTY, cell.getKey(), cell.getValue())));
  519.         print(output, format("afterExampleParameters", EMPTY));
  520.     }

  522.     @Override
  523.     public void afterExamples() {
  524.         print(format("exampleScenariosEnd", EMPTY));
  525.         print(format("afterExamples", NL));
  526.     }

  528.     @Override
  529.     public void dryRun() {
  530.         dryRun.set(true);
  531.     }

  533.     @Override
  534.     public void restarted(String step, Throwable cause) {
  535.         print(format("restarted", "{0} {1}\n", step, cause.getMessage()));
  536.     }
  537.     
  538.     @Override
  539.     public void restartedStory(Story story, Throwable cause) {
  540.         print(format("restartedStory", "{0} {1}\n", story.getPath(), cause.getMessage()));
  541.     }

  543.     /**
  544.      * Formats event output by key, usually equal to the method name.
  545.      * 
  546.      * @param key the event key
  547.      * @param defaultPattern the default pattern to return if a custom pattern
  548.      *            is not found
  549.      * @param args the args used to format output
  550.      * @return A formatted event output
  551.      */
  552.     protected String format(String key, String defaultPattern, Object... args) {
  553.         String escape = escape(defaultPattern);
  554.         String s = lookupPattern(key, escape);
  555.         Object[] objects = escapeAll(args);
  556.         return MessageFormat.format(s, objects);
  557.     }

  559.     protected String formatTable(ExamplesTable table) {
  560.         OutputStream formatted = new ByteArrayOutputStream();
  561.         PrintStream out = new PrintStream(formatted);
  562.         print(out, format("examplesTableStart", NL));
  563.         List<Map<String, String>> rows = table.getRows();
  564.         List<String> headers = table.getHeaders();
  565.         print(out, format("examplesTableHeadStart", "|"));
  566.         for (String header : headers) {
  567.             print(out, format("examplesTableHeadCell", "{0}|", header));
  568.         }
  569.         print(out, format("examplesTableHeadEnd", NL));
  570.         print(out, format("examplesTableBodyStart", EMPTY));
  571.         for (Map<String, String> row : rows) {
  572.             print(out, format("examplesTableRowStart", "|"));
  573.             for (String header : headers) {
  574.                 print(out, format("examplesTableCell", "{0}|", row.get(header)));
  575.             }
  576.             print(out, format("examplesTableRowEnd", NL));
  577.         }
  578.         print(out, format("examplesTableBodyEnd", EMPTY));
  579.         print(out, format("examplesTableEnd", EMPTY));
  580.         return formatted.toString();
  581.     }

  583.     protected String formatVerbatim(Verbatim verbatim) {
  584.         OutputStream formatted = new ByteArrayOutputStream();
  585.         PrintStream out = new PrintStream(formatted);
  586.         print(out, format("verbatimStart", NL));
  587.         print(out, verbatim.getContent());
  588.         print(out, format("verbatimEnd", NL));
  589.         return formatted.toString();
  590.     }

  592.     private Object[] escapeAll(Object... args) {
  593.         return escape(format, args);
  594.     }

  596.     private String escape(String defaultPattern) {
  597.         return (String) escapeAll(defaultPattern)[0];
  598.     }

  600.     /**
  601.      * Escapes args' string values according to format
  602.      *
  603.      * @param format the Format used by the PrintStream
  604.      * @param args the array of args to escape
  605.      * @return The cloned and escaped array of args
  606.      */
  607.     protected Object[] escape(final Format format, Object... args) {
  608.         // Transformer that escapes HTML,XML,JSON strings
  609.         return Stream.of(args).map(format::escapeValue).toArray();
  610.     }

  612.     /**
  613.      * Looks up the format pattern for the event output by key, conventionally
  614.      * equal to the method name. The pattern is used by the
  615.      * {#format(String,String,Object...)} method and by default is formatted
  616.      * using the {@link MessageFormat#format(String, Object...)} method. If no
  617.      * pattern is found for key or needs to be overridden, the default pattern
  618.      * should be returned.
  619.      * 
  620.      * @param key the format pattern key
  621.      * @param defaultPattern the default pattern if no pattern is
  622.      * @return The format patter for the given key
  623.      */
  624.     protected String lookupPattern(String key, String defaultPattern) {
  625.         if (outputPatterns.containsKey(key)) {
  626.             return outputPatterns.getProperty(key);
  627.         }
  628.         return defaultPattern;
  629.     }

  631.     public boolean reportFailureTrace() {
  632.         Boolean reportFailure = reportFailureTrace.get();
  633.         if (reportFailure != null) {
  634.             return reportFailure;
  635.         }
  636.         return false;
  637.     }

  639.     public PrintStreamOutput doReportFailureTrace(boolean reportFailureTrace) {
  640.         this.reportFailureTrace.set(reportFailureTrace);
  641.         return this;
  642.     }

  644.     public boolean compressFailureTrace() {
  645.         return compressFailureTrace.get();
  646.     }

  648.     public PrintStreamOutput doCompressFailureTrace(boolean compressFailureTrace) {
  649.         this.compressFailureTrace.set(compressFailureTrace);
  650.         return this;
  651.     }

  653.     protected void overwritePattern(String key, String pattern) {
  654.         outputPatterns.put(key, pattern);
  655.     }

  657.     /**
  658.      * Prints text to output stream, replacing parameter start and end
  659.      * placeholders
  660.      * 
  661.      * @param text the String to print
  662.      */
  663.     protected void print(String text) {
  664.         String tableStart = format(PARAMETER_TABLE_START, PARAMETER_TABLE_START);
  665.         String tableEnd = format(PARAMETER_TABLE_END, PARAMETER_TABLE_END);
  666.         boolean containsTable = text.contains(tableStart) && text.contains(tableEnd);
  667.         String verbatimStart = format(PARAMETER_VERBATIM_START, PARAMETER_VERBATIM_START);
  668.         String verbatimEnd = format(PARAMETER_VERBATIM_END, PARAMETER_VERBATIM_END);
  669.         boolean containsVerbatim = text.contains(verbatimStart) && text.contains(verbatimEnd);
  670.         String textToPrint;
  671.         if (containsTable) {
  672.             textToPrint = transformPrintingTable(text, tableStart, tableEnd);
  673.         } else if (containsVerbatim) {
  674.             textToPrint = transformPrintingVerbatim(text, verbatimStart, verbatimEnd);
  675.         } else {
  676.             textToPrint = text;
  677.         }
  678.         print(output, textToPrint
  679.                 .replace(format(PARAMETER_VALUE_START, PARAMETER_VALUE_START),
  680.                         format("parameterValueStart", EMPTY))
  681.                 .replace(format(PARAMETER_VALUE_END, PARAMETER_VALUE_END),
  682.                         format("parameterValueEnd", EMPTY))
  683.                 .replace(format(PARAMETER_VALUE_NEWLINE, PARAMETER_VALUE_NEWLINE),
  684.                         format("parameterValueNewline", NL)));
  685.     }

  687.     protected void print(PrintStream output, String text) {
  688.         output.print(text);
  689.     }

  691.     protected String transformPrintingTable(String text, String tableStart, String tableEnd) {
  692.         String tableAsString = substringBetween(text, tableStart, tableEnd);
  693.         return text
  694.                 .replace(tableAsString, formatTable(new ExamplesTable(tableAsString)))
  695.                 .replace(tableStart, format("parameterValueStart", EMPTY))
  696.                 .replace(tableEnd, format("parameterValueEnd", EMPTY));
  697.     }

  699.     protected String  transformPrintingVerbatim(String text, String verbatimStart, String verbatimEnd) {
  700.         String verbatimAsString = substringBetween(text, verbatimStart, verbatimEnd);
  701.         return text
  702.                 .replace(verbatimAsString, formatVerbatim(new Verbatim(verbatimAsString)))
  703.                 .replace(verbatimStart, format("parameterValueStart", EMPTY))
  704.                 .replace(verbatimEnd, format("parameterValueEnd", EMPTY));
  705.     }

  707.     @Override
  708.     public String toString() {
  709.         return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE).append(format).append(output).toString();
  710.     }
  711. }
Created with JaCoCo 0.8.10.202304240956