src/main/java/com/google/devtools/build/lib/exec/TestLogHelper.java

// Copyright 2014 The Bazel Authors. All rights reserved.
//
// 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 com.google.devtools.build.lib.exec;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.io.ByteStreams;
import com.google.devtools.build.lib.exec.ExecutionOptions.TestOutputFormat;
import com.google.devtools.build.lib.util.OS;
import com.google.devtools.build.lib.vfs.Path;
import java.io.BufferedOutputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;

/**
 * A helper class for test log handling. It determines whether the test log should be output and
 * formats the test log for console display.
 */
public class TestLogHelper {

  @VisibleForTesting
  static final String HEADER_DELIMITER =
      "-----------------------------------------------------------------------------";

  /**
   * Determines whether the test log should be output from the current outputMode and whether the
   * test has passed or not.
   */
  public static boolean shouldOutputTestLog(TestOutputFormat outputMode, boolean hasPassed) {
    return (outputMode == ExecutionOptions.TestOutputFormat.ALL)
        || (!hasPassed && (outputMode == ExecutionOptions.TestOutputFormat.ERRORS));
  }

  /**
   * Streams the contents of testOutput file to the provided output, adding a new header and footer.
   * The internal test header is elided. The test output is not emitted if its size is greater than
   * the provided threshold.
   *
   * @param maxTestOutputBytes Maximum test log size, including header, to output. Negative implies
   *     no limit.
   */
  public static void writeTestLog(
      Path testOutput, String testName, OutputStream out, int maxTestOutputBytes)
      throws IOException {
    PrintStream printOut = new PrintStream(new BufferedOutputStream(out));
    try {
      printOut.println("==================== Test output for " + testName + ":");
      printOut.flush();

      if (maxTestOutputBytes < 0) {
        // No limit, print it all.
        streamTestLog(testOutput, printOut);
      } else {
        long testOutputBytes = testOutput.getFileSize();
        if (testOutputBytes <= maxTestOutputBytes) {
          streamTestLog(testOutput, printOut);
        } else {
          printOut.printf(
              "Test log too large (%s > %s), skipping...\n", testOutputBytes, maxTestOutputBytes);
        }
      }

      printOut.println(
          "================================================================================");
    } finally {
      printOut.flush();
    }
  }

  /**
   * Returns an output stream that doesn't write to original until it sees HEADER_DELIMITER by
   * itself on a line.
   */
  public static FilterTestHeaderOutputStream getHeaderFilteringOutputStream(OutputStream original) {
    return new FilterTestHeaderOutputStream(original);
  }

  private TestLogHelper() {
    // Prevent Java from creating a public constructor.
  }

  /** Use this class to filter the streaming output of a test until we see the header delimiter. */
  public static class FilterTestHeaderOutputStream extends FilterOutputStream {

    private boolean seenDelimiter = false;
    private StringBuilder lineBuilder = new StringBuilder();

    private static final int NEWLINE = '\n';

    public FilterTestHeaderOutputStream(OutputStream out) {
      super(out);
    }

    @Override
    public void write(int b) throws IOException {
      if (seenDelimiter) {
        out.write(b);
      } else if (b == NEWLINE) {
        String line = lineBuilder.toString();
        lineBuilder = new StringBuilder();
        if (line.equals(TestLogHelper.HEADER_DELIMITER)
            ||
            // On Windows, the line break could be \r\n, we want this case to work as well.
            (OS.getCurrent() == OS.WINDOWS && line.equals(TestLogHelper.HEADER_DELIMITER + "\r"))) {
          seenDelimiter = true;
        }
      } else if (lineBuilder.length() <= TestLogHelper.HEADER_DELIMITER.length()) {
        lineBuilder.append((char) b);
      }
    }

    @Override
    public void write(byte[] b, int off, int len) throws IOException {
      if (seenDelimiter) {
        out.write(b, off, len);
      } else {
        super.write(b, off, len);
      }
    }

    public boolean foundHeader() {
      return seenDelimiter;
    }
  }

  private static void streamTestLog(Path fromPath, PrintStream out) throws IOException {
    FilterTestHeaderOutputStream filteringOutputStream = getHeaderFilteringOutputStream(out);
    try (InputStream input = fromPath.getInputStream()) {
      ByteStreams.copy(input, filteringOutputStream);
    }

    if (!filteringOutputStream.foundHeader()) {
      try (InputStream inputAgain = fromPath.getInputStream()) {
        ByteStreams.copy(inputAgain, out);
      }
    }
  }
}