List<String> nonCommentLines;
        if (lastCommentLine != -1) {
            lines.remove(lastCommentLine);
            nonCommentLines = lines.subList(lastCommentLine, lines.size());
        } else {
            nonCommentLines = lines;
        }

        Collections.sort(nonCommentLines);
        StringBuilder builder = new StringBuilder();
        for (String line : lines) {

    // region: assertLinesContainedIn
    def "neither expected or actual lines can be empty"() {
        when:
        comparer.assertLinesContainedIn([], ["a"])
        then:
        thrown(AssertionError)

        when:
        comparer.assertLinesContainedIn(["a"], [])
        then:
        thrown(AssertionError)
    }

    def "successful lines contained in comparisons: #expectedLines vs #actualLines"() {
        expect:

  private final char[] buf = cbuf.array();

  private final Queue<String> lines = new ArrayDeque<>();
  private final LineBuffer lineBuf =
      new LineBuffer() {
        @Override
        protected void handleLine(String line, String end) {
          lines.add(line);
        }
      };

  /** Creates a new instance that will read lines from the given {@code Readable} object. */
  public LineReader(Readable readable) {

    def consoleLayoutCalculator = new ConsoleLayoutCalculator(consoleMetaData);

    def "lines should be ideal value if console is large enough"() {
        given:
        1 * consoleMetaData.getRows() >> 100

        expect:
        consoleLayoutCalculator.calculateNumWorkersForConsoleDisplay(5) == 5
    }

    def "lines should be half the console size for small consoles"() {
        given:

    /**
     * Reads the last {@code tailSize} lines of the daemon log file and returns them as a single string.
     *
     * @param file the daemon log
     * @param tailSize the length of tail
     * @return the tail of the log or a special {@code "<<empty>>"} string if the log is empty
     */
    static String tail(File file, int tailSize) throws IOException {
        try (Stream<String> lines = Files.lines(file.toPath(), StandardCharsets.UTF_8)) {

    }

    // Splits into lines.
    SmallVector<StringRef, 8> lines;
    file->getBuffer().split(lines, "\n", -1, false);
    // The resize method is used since split operator puts tail value in the end
    // without splitting the leftovers.
    if (op.getVocabSize() != -1) lines.resize(op.getVocabSize());

    // Map each line to line number, starting from zero.
    SmallVector<int64_t, 8> line_nums;

    filter(FixCrLfFilter)
    filter(ReplaceTokens, tokens: [copyright: '2009', version: '2.3.1'])
    // Use a closure to filter each line
    filter { String line ->
        "[$line]"
    }
    // Use a closure to remove lines
    filter { String line ->
        line.startsWith('-') ? null : line
    }
    filteringCharset = 'UTF-8'
}
// end::filter-files[]

// tag::file-permissions[]

            return clazz.getResource(RESOURCE)
                .readText()
                .split('\n')
                .filter { it.isNotBlank() }
                .map { line -> line.substring(7, line.length - 2) }
        }
    }

	//        server        0.182        0.000         40ms         74ms         97ms
	//
	lines := strings.Split(output, "\n")
	if len(lines) != 3 {
		t.Logf("Expected 2 lines of output, got %q", output)
		return errors.New("unexpected output (incorrect number of lines)")
	}
	fields := strings.Fields(lines[1])
	if len(fields) != 6 {
		t.Logf("Expected 6 columns, got %#v", fields)

	}
}

func runbench(b *testing.B, path string, ignoreFuncBodies, writeInfo bool) {
	files, err := pkgFiles(path)
	if err != nil {
		b.Fatal(err)
	}

	// determine line count
	var lines uint
	for _, f := range files {
		lines += f.EOF.Line()
	}

	b.ResetTimer()
	start := time.Now()
	for i := 0; i < b.N; i++ {
		conf := Config{
			IgnoreFuncBodies: ignoreFuncBodies,
			Importer:         defaultImporter(),