ActionReporter.java
package com.github.dakusui.actionunit.visitors;
import com.github.dakusui.actionunit.actions.Composite;
import com.github.dakusui.actionunit.core.Action;
import com.github.dakusui.actionunit.io.Writer;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import static java.lang.String.format;
import static java.util.Objects.requireNonNull;
/**
* A basic action reporter which writes an action tree and its report to given writers
*
* @see ReportingActionPerformer
*/
public class ActionReporter extends ActionPrinter {
public static final Predicate<Action> DEFAULT_CONDITION_TO_SQUASH_ACTION = v -> v instanceof Composite;
private final List<Boolean> failingContext = new LinkedList<>();
private final Predicate<Action> conditionToSquashAction;
private int emptyLevel = 0;
private int depth = 0;
private final Map<Action, Record> report;
private final Writer warnWriter;
private final Writer traceWriter;
private final Writer debugWriter;
private final Writer infoWriter;
private final int forcePrintLevelForUnexercisedActions;
String previousIndent = "";
/**
* Creates an object of this class.
* This reporter implements a functionality to squash actions to make output concise.
* It is controlled by a predicate given through `conditionToSquashAction` parameter.
* Also, depending on whether an action is exercised or not, a writer used to print it out will be chosen by internal logic of this class.
* Furthermore, actions in a deep level of a tree will be considered "unexercised" forcibly.
* The threshold level can be controlled by the parameter `forcePrintLevelForUnexercisedActions`.
*
* @param conditionToSquashAction A condition to "squash" a record of an action to make report concise.
* @param warnWriter A writer used for "warn" level.
* @param infoWriter A writer used for "info" level.
* @param debugWriter A writer used for "debug" level.
* @param traceWriter A writer used for "trace" level.
* @param report A map that stores an action tree's result.
* @param forcePrintLevelForUnexercisedActions A level under which action should be considered to be "unexercised".
*/
public ActionReporter(Predicate<Action> conditionToSquashAction, Writer warnWriter, Writer infoWriter, Writer debugWriter, Writer traceWriter, Map<Action, Record> report, int forcePrintLevelForUnexercisedActions) {
super(infoWriter);
this.conditionToSquashAction = conditionToSquashAction;
this.report = requireNonNull(report);
this.warnWriter = requireNonNull(warnWriter);
this.debugWriter = requireNonNull(debugWriter);
this.infoWriter = infoWriter;
this.traceWriter = traceWriter;
this.forcePrintLevelForUnexercisedActions = forcePrintLevelForUnexercisedActions;
}
/**
* Creates an action of this class.
*
* @param writer A writer through which a report is written.
* @param report A report data that records the result of actions in the tree.
*/
public ActionReporter(Writer writer, Map<Action, Record> report) {
this(DEFAULT_CONDITION_TO_SQUASH_ACTION, writer, writer, writer, writer, report, 2);
}
/**
* An entry-point to start reporting.
*
* @param action An action from which reporting starts.
*/
public void report(Action action) {
requireNonNull(action).accept(this);
}
@Override
protected void handleAction(Action action) {
if (this.conditionToSquashAction.test(action)) {
this.previousIndent = indent();
return;
}
Record runs = report.get(action);
String message = format("%s[%s]%s", indent(), runs != null ? runs : "", action);
this.previousIndent = "";
if (isInFailingContext()) {
this.warnWriter.writeLine(message);
} else {
if (emptyLevel < 1) { // Top level unexercised + exercised ones
if (passingLevels() < 1) {
this.infoWriter.writeLine(message);
} else {
writeLineForUnexercisedAction(message);
}
} else {
writeLineForUnexercisedAction(message);
}
}
}
/**
* //@formatter.off
* ----
* > [E:0]for each of (noname) parallely
* > +-[EE:0]print1
* > | [EE:0](noname)
* > +-[]print2
* > | [](noname)
* > +-[]print2-1
* > | [](noname)
* > +-[]print2-2
* > [](noname)
* ----
* //@format:on
*/
@Override
public String indent() {
List<? extends Action> path = this.path();
StringBuilder b = new StringBuilder();
if (!path.isEmpty()) {
Action last = path.get(path.size() - 1);
for (Action each : path) {
if (each instanceof Composite) {
if (each == last) {
if (((Composite) each).isParallel())
b.append("*-");
else
b.append("+-");
} else {
if (isLastChild(nextOf(each, path), each))
b.append(" ");
else
b.append("| ");
}
} else {
b.append(" ");
}
}
}
return mergeStrings(this.previousIndent, b.toString());
}
@Override
protected void enter(Action action) {
super.enter(action);
depth++;
Record runs = report.get(action);
pushFailingContext(runs != null && runs.allFailing());
if (runs == null)
emptyLevel++;
}
@Override
protected void leave(Action action) {
Record runs = report.get(action);
if (runs == null)
emptyLevel--;
popFailingContext();
depth--;
super.leave(action);
}
boolean isInFailingContext() {
return !this.failingContext.isEmpty() && this.failingContext.get(0);
}
void pushFailingContext(boolean newContext) {
failingContext.add(0, newContext);
}
void popFailingContext() {
failingContext.remove(0);
}
private void writeLineForUnexercisedAction(String message) {
// unexercised
if (depth < this.forcePrintLevelForUnexercisedActions)
this.debugWriter.writeLine(message);
else
this.traceWriter.writeLine(message);
}
private int passingLevels() {
int ret = 0;
for (boolean each : this.failingContext)
if (!each)
ret++;
return ret;
}
private static Action nextOf(Action each, List<? extends Action> path) {
return path.get(path.indexOf(each) + 1);
}
/**
* Merges two string into one.
* A white space in `a` or `b` will be replaced with non-white space in the other at the same position.
* In case both have non-white space in the same position, the latter's (`b`) overrides the first's (`a`).
* <p>
* .Example input
* ----
* a:"hello "
* b:" O WORLD "
* ----
* <p>
* .Example output
* ----
* "hellO WORLD "
* ----
*
* @param a A string to be merged.
* @param b A stringto be merged
* @return The merged result string.
*/
private static String mergeStrings(String a, String b) {
StringBuilder builder = new StringBuilder();
int min = Math.min(a.length(), b.length());
for (int i = 0; i < min; i++) {
char ach = a.charAt(i);
char bch = b.charAt(i);
if (bch != ' ')
builder.append(bch);
else
builder.append(ach);
}
// Whichever longer, the result is the same since the shorter.substring(min) will become an empty
// string.
builder.append(a.substring(min));
builder.append(b.substring(min));
return builder.toString();
}
private static boolean isLastChild(Action each, Action parent) {
if (parent instanceof Composite) {
int index = ((Composite) parent).children().indexOf(each);
int size = ((Composite) parent).children().size();
assert index >= 0;
return index == size - 1;
}
return true;
}
}