Issue cucumber#207 UsageFormatter

core/src/main/java/cucumber/formatter/FormatterFactory.java

@@ -1,5 +1,7 @@
 package cucumber.formatter;
 
+import cucumber.formatter.usage.AverageUsageStatisticStrategy;
+import cucumber.formatter.usage.MedianUsageStatisticStrategy;
 import cucumber.runtime.CucumberException;
 import gherkin.formatter.Formatter;
 import gherkin.formatter.JSONFormatter;
@@ -8,6 +10,7 @@
 
 import java.io.File;
 import java.io.FileWriter;
+import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -21,6 +24,7 @@ public class FormatterFactory {
  put("json", JSONFormatter.class.getName());
  put("json-pretty", JSONPrettyFormatter.class.getName());
  put("pretty", PrettyFormatter.class.getName());
+ put("usage", UsageFormatter.class.getName());
  }};
 
  public FormatterFactory(ClassLoader classLoader) {
@@ -51,6 +55,8 @@ private Formatter createFormatterFromClassName(String className, Object out) {
  return formatterClass.getConstructor(ctorArgClass, Boolean.TYPE, Boolean.TYPE).newInstance(out, false, true);
  } else if (ProgressFormatter.class.isAssignableFrom(formatterClass)) {
  return formatterClass.getConstructor(ctorArgClass, Boolean.TYPE).newInstance(out, false);
+ } else if (UsageFormatter.class.isAssignableFrom(formatterClass)) {
+ return createUsageFormatter(out, ctorArgClass, formatterClass);
  } else {
  return formatterClass.getConstructor(ctorArgClass).newInstance(out);
  }
@@ -66,4 +72,12 @@ private Class<Formatter> getFormatterClass(String className) {
  throw new CucumberException("Formatter class not found: " + className, e);
  }
  }
+
+ private UsageFormatter createUsageFormatter(Object out, Class ctorArgClass, Class<Formatter> formatterClass) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException
+ {
+ UsageFormatter formatter = (UsageFormatter)formatterClass.getConstructor(ctorArgClass).newInstance(out);
+ formatter.addUsageStatisticStrategy("average", new AverageUsageStatisticStrategy());
+ formatter.addUsageStatisticStrategy("median", new MedianUsageStatisticStrategy());
+ return formatter;
+ }
 }

core/src/main/java/cucumber/formatter/UsageFormatter.java

@@ -0,0 +1,217 @@
+package cucumber.formatter;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import cucumber.formatter.usage.UsageStatisticStrategy;
+import gherkin.formatter.Format;
+import gherkin.formatter.Formatter;
+import gherkin.formatter.MonochromeFormats;
+import gherkin.formatter.NiceAppendable;
+import gherkin.formatter.Reporter;
+import gherkin.formatter.StepPrinter;
+import gherkin.formatter.model.Background;
+import gherkin.formatter.model.Examples;
+import gherkin.formatter.model.Feature;
+import gherkin.formatter.model.Match;
+import gherkin.formatter.model.Result;
+import gherkin.formatter.model.Scenario;
+import gherkin.formatter.model.ScenarioOutline;
+import gherkin.formatter.model.Step;
+
+/**
+ * Formatter to measure performance of steps. Aggregated results for all steps can be computed
+ * by adding {@link UsageStatisticStrategy} to the usageFormatter
+ */
+public class UsageFormatter implements Formatter, Reporter
+{
+ private final MonochromeFormats monochromeFormat = new MonochromeFormats();
+ private final StepPrinter stepPrinter = new StepPrinter();
+
+ final Map<String, List<Long>> usageMap = new HashMap<String, List<Long>>();
+ final Map<String, UsageStatisticStrategy> statisticStrategies = new HashMap<String, UsageStatisticStrategy>();
+
+ private final List<Step> steps = new ArrayList<Step>();
+ private final NiceAppendable out;
+
+ private Match match;
+
+ /**
+ * Constructor
+ * @param out {@link Appendable} to print the result
+ */
+ public UsageFormatter(Appendable out)
+ {
+ this.out = new NiceAppendable(out);
+ }
+
+ @Override
+ public void uri(String uri)
+ {
+ }
+
+ @Override
+ public void feature(Feature feature)
+ {
+ }
+
+ @Override
+ public void background(Background background)
+ {
+ }
+
+ @Override
+ public void scenario(Scenario scenario)
+ {
+ }
+
+ @Override
+ public void scenarioOutline(ScenarioOutline scenarioOutline)
+ {
+ }
+
+ @Override
+ public void examples(Examples examples)
+ {
+ }
+
+ @Override
+ public void step(Step step)
+ {
+ steps.add(step);
+ }
+
+ @Override
+ public void eof()
+ {
+ }
+
+ @Override
+ public void syntaxError(String state, String event, List<String> legalEvents, String uri, int line)
+ {
+ }
+
+ @Override
+ public void done()
+ {
+ for (Map.Entry<String, List<Long>> usageEntry : usageMap.entrySet())
+ {
+ printAggregatedResult(usageEntry);
+
+ String key = usageEntry.getKey();
+ for (Long duration : usageEntry.getValue())
+ {
+ printSingleDurationEntry(key, duration);
+ }
+ }
+ }
+
+ private void printAggregatedResult(Map.Entry<String, List<Long>> usageEntry)
+ {
+ String stepName = usageEntry.getKey();
+ for (Map.Entry<String, UsageStatisticStrategy> calculatorEntry : statisticStrategies.entrySet())
+ {
+ String calculatorName = calculatorEntry.getKey();
+ UsageStatisticStrategy statisticStrategy = calculatorEntry.getValue();
+
+ Long calculationResult = statisticStrategy.calculate(usageEntry.getValue());
+ out.println(String.format("%s (%s) : %s", formatDuration(calculationResult), calculatorName, stepName));
+ }
+ }
+
+ private void printSingleDurationEntry(String key, Long duration)
+ {
+ String formattedDuration = formatDuration(duration);
+ out.println("\t" + formattedDuration + " : " + key);
+ }
+
+ private String formatDuration(Long duration)
+ {
+ long seconds = TimeUnit.MICROSECONDS.toSeconds(duration);
+ long microSeconds = duration - TimeUnit.SECONDS.toMicros(seconds);
+ return String.format("%d.%06d", seconds, microSeconds);
+ }
+
+ @Override
+ public void close()
+ {
+ out.close();
+ }
+
+ @Override
+ public void result(Result result)
+ {
+ if (steps.size() > 0)
+ {
+ Step step = steps.remove(0);
+ String stepNameWithArgs = formatStepNameWithArgs(result, step);
+ addUsageEntry(result, stepNameWithArgs);
+ }
+ }
+
+ private String formatStepNameWithArgs(Result result, Step step)
+ {
+ StringBuffer buffer = new StringBuffer();
+ Format format = getFormat(result.getStatus());
+ Format argFormat = getArgFormat(result.getStatus());
+ stepPrinter.writeStep(new NiceAppendable(buffer), format, argFormat, step.getName(), match.getArguments());
+
+ return buffer.toString();
+ }
+
+ private void addUsageEntry(Result result, String stepNameWithArgs)
+ {
+ List<Long> durationEntries = usageMap.get(stepNameWithArgs);
+ if (durationEntries == null)
+ {
+ durationEntries = new ArrayList<Long>();
+ usageMap.put(stepNameWithArgs, durationEntries);
+ }
+ durationEntries.add(durationInMillis(result));
+ }
+
+ private Long durationInMillis(Result result)
+ {
+ long duration;
+ if (result.getDuration() == null)
+ {
+ duration = 0;
+ } else
+ {
+ duration = result.getDuration() / 1000;
+ }
+ return duration;
+ }
+
+ @Override
+ public void match(Match match)
+ {
+ this.match = match;
+ }
+
+ @Override
+ public void embedding(String mimeType, byte[] data)
+ {
+ }
+
+ private Format getFormat(String key) {
+ return monochromeFormat.get(key);
+ }
+
+ private Format getArgFormat(String key) {
+ return monochromeFormat.get(key + "_arg");
+ }
+
+ /**
+ * Add a {@link UsageStatisticStrategy} to the formatter
+ * @param key the key, will be displayed in the output
+ * @param strategy the strategy
+ */
+ public void addUsageStatisticStrategy(String key, UsageStatisticStrategy strategy)
+ {
+ statisticStrategies.put(key, strategy);
+ }
+}

core/src/main/java/cucumber/formatter/usage/AverageUsageStatisticStrategy.java

@@ -0,0 +1,30 @@
+package cucumber.formatter.usage;
+
+import java.util.List;
+
+/**
+ * Calculate the average of a list of duration entries
+ */
+public class AverageUsageStatisticStrategy implements UsageStatisticStrategy
+{
+ @Override
+ public Long calculate(List<Long> durationEntries)
+ {
+ if (verifyNoNulls(durationEntries))
+ {
+ return 0L;
+ }
+
+ long sum = 0;
+ for (Long duration : durationEntries)
+ {
+ sum += duration;
+ }
+ return sum / durationEntries.size();
+ }
+
+ private boolean verifyNoNulls(List<Long> durationEntries)
+ {
+ return durationEntries == null || durationEntries.isEmpty() || durationEntries.contains(null);
+ }
+}

core/src/main/java/cucumber/formatter/usage/MedianUsageStatisticStrategy.java

@@ -0,0 +1,34 @@
+package cucumber.formatter.usage;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Calculate the median of a list of duration entries
+ */
+public class MedianUsageStatisticStrategy implements UsageStatisticStrategy
+{
+ @Override
+ public Long calculate(List<Long> durationEntries)
+ {
+ if (verifyNoNulls(durationEntries))
+ {
+ return 0L;
+ }
+ Collections.sort(durationEntries);
+ int middle = durationEntries.size() / 2;
+ if (durationEntries.size() % 2 == 1)
+ {
+ return durationEntries.get(middle);
+ }
+ else
+ {
+ return (durationEntries.get(middle - 1) + durationEntries.get(middle)) / 2;
+ }
+ }
+
+ private boolean verifyNoNulls(List<Long> durationEntries)
+ {
+ return durationEntries == null || durationEntries.isEmpty() || durationEntries.contains(null);
+ }
+}

core/src/main/java/cucumber/formatter/usage/UsageStatisticStrategy.java

@@ -0,0 +1,15 @@
+package cucumber.formatter.usage;
+
+import java.util.List;
+
+/**
+ * Calculate a statistical value to be displayed in the usage-file
+ */
+public interface UsageStatisticStrategy
+{
+ /**
+ * @param durationEntries list of execution times of steps as nanoseconds
+ * @return a statistical value (e.g. median, average, ..)
+ */
+ Long calculate(List<Long> durationEntries);
+}

core/src/test/java/cucumber/formatter/FormatterFactoryTest.java

@@ -1,5 +1,8 @@
 package cucumber.formatter;
 
+import cucumber.formatter.usage.AverageUsageStatisticStrategy;
+import cucumber.formatter.usage.MedianUsageStatisticStrategy;
+import cucumber.formatter.usage.UsageStatisticStrategy;
 import gherkin.formatter.Formatter;
 import gherkin.formatter.JSONFormatter;
 import gherkin.formatter.JSONPrettyFormatter;
@@ -8,10 +11,13 @@
 
 import java.io.File;
 import java.io.StringWriter;
+import java.util.Map;
 
 import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.mock;
 
 public class FormatterFactoryTest {
 
@@ -42,6 +48,18 @@ public void shouldInstantiateHtmlFormatter() {
  assertThat(formatterFactory.createFormatter("html", new File(System.getProperty("user.dir"))), is(HTMLFormatter.class));
  }
 
+
+ @Test
+ public void shouldInstantiateUsageFormatter() {
+ Formatter formatter = formatterFactory.createFormatter("usage", mock(Appendable.class));
+
+ assertThat(formatter, is(UsageFormatter.class));
+ Map<String,UsageStatisticStrategy> statisticStrategies = ((UsageFormatter) formatter).statisticStrategies;
+ assertEquals(statisticStrategies.size(), 2);
+ assertThat(statisticStrategies.get("average"), is(AverageUsageStatisticStrategy.class));
+ assertThat(statisticStrategies.get("median"), is(MedianUsageStatisticStrategy.class));
+ }
+
  @Test
  public void shouldInstantiateCustomFormatterFromClassNameWithAppender() {
  StringWriter writer = new StringWriter();
@@ -57,5 +75,4 @@ public void shouldInstantiateCustomFormatterFromClassNameWithDirFile() {
  assertThat(formatter, is(TestFormatter.class));
  assertSame(dir, ((TestFormatter) formatter).dir);
  }
-
 }