/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package vogar;
import com.google.common.collect.Lists;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import vogar.util.MarkResetConsole;
/**
* Controls, formats and emits output to the command line. This class emits
* output in two modes:
* <ul>
* <li><strong>Streaming</strong> output prints as it is received, but cannot
* support multiple concurrent output streams.
* <li><strong>Multiplexing</strong> buffers output until it is complete and
* then prints it completely.
* </ul>
*/
public abstract class Console implements Log {
static final long DAY_MILLIS = 1000 * 60 * 60 * 24;
static final long HOUR_MILLIS = 1000 * 60 * 60;
static final long WARNING_HOURS = 12;
static final long FAILURE_HOURS = 48;
private boolean useColor;
private boolean ansi;
private boolean verbose;
protected String indent;
protected CurrentLine currentLine = CurrentLine.NEW;
protected final MarkResetConsole out = new MarkResetConsole(System.out);
protected MarkResetConsole.Mark currentVerboseMark;
protected MarkResetConsole.Mark currentStreamMark;
private Console() {}
public void setIndent(String indent) {
this.indent = indent;
}
public void setUseColor(
boolean useColor, int passColor, int skipColor, int failColor, int warnColor) {
this.useColor = useColor;
Color.PASS.setCode(passColor);
Color.SKIP.setCode(skipColor);
Color.FAIL.setCode(failColor);
Color.WARN.setCode(warnColor);
Color.COMMENT.setCode(34);
}
public void setAnsi(boolean ansi) {
this.ansi = ansi;
}
public void setVerbose(boolean verbose) {
this.verbose = verbose;
}
public boolean isVerbose() {
return verbose;
}
public synchronized void verbose(String s) {
/*
* terminal does't support overwriting output, so don't print
* verbose message unless requested.
*/
if (!verbose && !ansi) {
return;
}
/*
* When writing verbose output in the middle of streamed output, keep
* the streamed mark location. That way we can remove the verbose output
* later without losing our position mid-line in the streamed output.
*/
MarkResetConsole.Mark savedStreamMark = currentLine == CurrentLine.STREAMED_OUTPUT
? out.mark()
: currentStreamMark;
newLine();
currentStreamMark = savedStreamMark;
currentVerboseMark = out.mark();
out.print(s);
currentLine = CurrentLine.VERBOSE;
}
public synchronized void warn(String message) {
warn(message, Collections.<String>emptyList());
}
/**
* Warns, and also puts a list of strings afterwards.
*/
public synchronized void warn(String message, List<String> list) {
newLine();
out.println(colorString("Warning: " + message, Color.WARN));
for (String item : list) {
out.println(colorString(indent + item, Color.WARN));
}
}
public synchronized void info(String s) {
newLine();
out.println(s);
}
public synchronized void info(String message, Throwable throwable) {
newLine();
out.println(message);
throwable.printStackTrace(System.out);
}
/**
* Begins streaming output for the named action.
*/
public void action(String name) {}
/**
* Begins streaming output for the named outcome.
*/
public void outcome(String name) {}
/**
* Appends the action output immediately to the stream when streaming is on,
* or to a buffer when streaming is off. Buffered output will be held and
* printed only if the outcome is unsuccessful.
*/
public abstract void streamOutput(String outcomeName, String output);
/**
* Hook to flush anything streamed via {@link #streamOutput}.
*/
protected void flushBufferedOutput(String outcomeName) {}
/**
* Writes the action's outcome.
*/
public synchronized void printResult(
String outcomeName, Result result, ResultValue resultValue, Expectation expectation) {
// when the result is interesting, include the description and bug number
if (result != Result.SUCCESS || resultValue != ResultValue.OK) {
if (!expectation.getDescription().isEmpty()) {
streamOutput(outcomeName, "\n" + colorString(expectation.getDescription(), Color.COMMENT));
}
if (expectation.getBug() != -1) {
streamOutput(outcomeName, "\n" + colorString("http://b/" + expectation.getBug(), Color.COMMENT));
}
}
flushBufferedOutput(outcomeName);
if (currentLine == CurrentLine.NAME) {
out.print(" ");
} else {
newLine(); // TODO: backup the cursor up to the name if there's no streaming output
out.print(indent + outcomeName + " ");
}
if (resultValue == ResultValue.OK) {
out.println(colorString("OK (" + result + ")", Color.PASS));
} else if (resultValue == ResultValue.FAIL) {
out.println(colorString("FAIL (" + result + ")", Color.FAIL));
} else if (resultValue == ResultValue.IGNORE) {
out.println(colorString("SKIP (" + result + ")", Color.WARN));
}
currentLine = CurrentLine.NEW;
}
public synchronized void summarizeOutcomes(Collection<AnnotatedOutcome> annotatedOutcomes) {
List<AnnotatedOutcome> annotatedOutcomesSorted =
AnnotatedOutcome.ORDER_BY_NAME.sortedCopy(annotatedOutcomes);
List<String> failures = Lists.newArrayList();
List<String> skips = Lists.newArrayList();
List<String> successes = Lists.newArrayList();
List<String> warnings = Lists.newArrayList();
// figure out whether each outcome is noteworthy, and add a message to the appropriate list
for (AnnotatedOutcome annotatedOutcome : annotatedOutcomesSorted) {
if (!annotatedOutcome.isNoteworthy()) {
continue;
}
Color color;
List<String> list;
ResultValue resultValue = annotatedOutcome.getResultValue();
if (resultValue == ResultValue.OK) {
color = Color.PASS;
list = successes;
} else if (resultValue == ResultValue.FAIL) {
color = Color.FAIL;
list = failures;
} else if (resultValue == ResultValue.WARNING) {
color = Color.WARN;
list = warnings;
} else {
color = Color.SKIP;
list = skips;
}
Long lastRun = annotatedOutcome.lastRun(null);
String timestamp;
if (lastRun == null) {
timestamp = colorString("unknown", Color.WARN);
} else {
timestamp = formatElapsedTime(new Date().getTime() - lastRun);
}
String brokeThisMessage = "";
ResultValue mostRecentResultValue = annotatedOutcome.getMostRecentResultValue(null);
if (mostRecentResultValue != null && resultValue != mostRecentResultValue) {
if (resultValue == ResultValue.OK) {
brokeThisMessage = colorString(" (you might have fixed this)", Color.WARN);
} else {
brokeThisMessage = colorString(" (you might have broken this)", Color.WARN);
}
} else if (mostRecentResultValue == null) {
brokeThisMessage = colorString(" (no test history available)", Color.WARN);
}
List<ResultValue> previousResultValues = annotatedOutcome.getPreviousResultValues();
int numPreviousResultValues = previousResultValues.size();
int numResultValuesToShow = Math.min(10, numPreviousResultValues);
List<ResultValue> previousResultValuesToShow = previousResultValues.subList(
numPreviousResultValues - numResultValuesToShow, numPreviousResultValues);
StringBuilder sb = new StringBuilder();
sb.append(indent);
sb.append(colorString(annotatedOutcome.getOutcome().getName(), color));
if (!previousResultValuesToShow.isEmpty()) {
sb.append(String.format(" [last %d: %s] [last run: %s]",
previousResultValuesToShow.size(),
generateSparkLine(previousResultValuesToShow),
timestamp));
}
sb.append(brokeThisMessage);
list.add(sb.toString());
}
newLine();
if (!successes.isEmpty()) {
out.println("Success summary:");
for (String success : successes) {
out.println(success);
}
}
if (!failures.isEmpty()) {
out.println("Failure summary:");
for (String failure : failures) {
out.println(failure);
}
}
if (!skips.isEmpty()) {
out.println("Skips summary:");
for (String skip : skips) {
out.println(skip);
}
}
if (!warnings.isEmpty()) {
out.println("Warnings summary:");
for (String warning : warnings) {
out.println(warning);
}
}
}
private String formatElapsedTime(long elapsedTime) {
if (elapsedTime < 0) {
throw new IllegalArgumentException("non-negative elapsed times only");
}
String formatted;
if (elapsedTime >= DAY_MILLIS) {
long days = elapsedTime / DAY_MILLIS;
formatted = String.format("%d days ago", days);
} else if (elapsedTime >= HOUR_MILLIS) {
long hours = elapsedTime / HOUR_MILLIS;
formatted = String.format("%d hours ago", hours);
} else {
formatted = "less than an hour ago";
}
Color color = elapsedTimeWarningColor(elapsedTime);
return colorString(formatted, color);
}
private Color elapsedTimeWarningColor(long elapsedTime) {
if (elapsedTime < WARNING_HOURS * HOUR_MILLIS) {
return Color.PASS;
} else if (elapsedTime < FAILURE_HOURS * HOUR_MILLIS) {
return Color.WARN;
} else {
return Color.FAIL;
}
}
private String generateSparkLine(List<ResultValue> resultValues) {
StringBuilder sb = new StringBuilder();
for (ResultValue resultValue : resultValues) {
if (resultValue == ResultValue.OK) {
sb.append(colorString("\u2713", Color.PASS));
} else if (resultValue == ResultValue.FAIL) {
sb.append(colorString("X", Color.FAIL));
} else {
sb.append(colorString("-", Color.WARN));
}
}
return sb.toString();
}
/**
* Prints the action output with appropriate indentation.
*/
public synchronized void streamOutput(CharSequence streamedOutput) {
if (streamedOutput.length() == 0) {
return;
}
String[] lines = messageToLines(streamedOutput.toString());
if (currentLine == CurrentLine.VERBOSE && currentStreamMark != null && ansi) {
currentStreamMark.reset();
currentStreamMark = null;
} else if (currentLine != CurrentLine.STREAMED_OUTPUT) {
newLine();
out.print(indent);
out.print(indent);
}
out.print(lines[0]);
currentLine = CurrentLine.STREAMED_OUTPUT;
for (int i = 1; i < lines.length; i++) {
newLine();
if (lines[i].length() > 0) {
out.print(indent);
out.print(indent);
out.print(lines[i]);
currentLine = CurrentLine.STREAMED_OUTPUT;
}
}
}
/**
* Inserts a linebreak if necessary.
*/
protected void newLine() {
currentStreamMark = null;
if (currentLine == CurrentLine.VERBOSE && !verbose && ansi) {
/*
* Verbose means we leave all verbose output on the screen.
* Otherwise we overwrite verbose output when new output arrives.
*/
currentVerboseMark.reset();
} else if (currentLine != CurrentLine.NEW) {
out.print("\n");
}
currentLine = CurrentLine.NEW;
}
/**
* Status of a currently-in-progress line of output.
*/
enum CurrentLine {
/**
* The line is blank.
*/
NEW,
/**
* The line contains streamed application output. Additional streamed
* output may be appended without additional line separators or
* indentation.
*/
STREAMED_OUTPUT,
/**
* The line contains the name of an action or outcome. The outcome's
* result (such as "OK") can be appended without additional line
* separators or indentation.
*/
NAME,
/**
* The line contains verbose output, and may be overwritten.
*/
VERBOSE,
}
/**
* Returns an array containing the lines of the given text.
*/
private String[] messageToLines(String message) {
// pass Integer.MAX_VALUE so split doesn't trim trailing empty strings.
return message.split("\r\n|\r|\n", Integer.MAX_VALUE);
}
private enum Color {
PASS, FAIL, SKIP, WARN, COMMENT;
int code = 0;
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
}
protected String colorString(String message, Color color) {
return useColor ? ("\u001b[" + color.getCode() + ";1m" + message + "\u001b[0m") : message;
}
/**
* This console prints output as it's emitted. It supports at most one
* action at a time.
*/
static class StreamingConsole extends Console {
private String currentName;
@Override public synchronized void action(String name) {
newLine();
out.print("Action " + name);
currentName = name;
currentLine = CurrentLine.NAME;
}
/**
* Prints the beginning of the named outcome.
*/
@Override public synchronized void outcome(String name) {
// if the outcome and action names are the same, omit the outcome name
if (name.equals(currentName)) {
return;
}
currentName = name;
newLine();
out.print(indent + name);
currentLine = CurrentLine.NAME;
}
@Override public synchronized void streamOutput(String outcomeName, String output) {
streamOutput(output);
}
}
/**
* This console buffers output, only printing when a result is found. It
* supports multiple concurrent actions.
*/
static class MultiplexingConsole extends Console {
private final Map<String, StringBuilder> bufferedOutputByOutcome = new HashMap<String, StringBuilder>();
@Override public synchronized void streamOutput(String outcomeName, String output) {
StringBuilder buffer = bufferedOutputByOutcome.get(outcomeName);
if (buffer == null) {
buffer = new StringBuilder();
bufferedOutputByOutcome.put(outcomeName, buffer);
}
buffer.append(output);
}
@Override protected synchronized void flushBufferedOutput(String outcomeName) {
newLine();
out.print(indent + outcomeName);
currentLine = CurrentLine.NAME;
StringBuilder buffer = bufferedOutputByOutcome.remove(outcomeName);
if (buffer != null) {
streamOutput(buffer);
}
}
}
}