lines = file("output.txt").text.readLines()

        then:
        lines.containsAll([
                'error',
                'System.out',
                'System.err'
        ])

        and:
        !lines.contains('debug')
        !lines.contains('info')
        !lines.contains('lifecycle')
        !lines.contains('warn')
    }

        List<String> lines = output.readLines()
        int buildSuccessfulLineIndex = lines.indexOf("BUILD SUCCESSFUL in 0s")
        assert buildSuccessfulLineIndex != -1

        List<String> normalized = lines.subList(0, buildSuccessfulLineIndex).grep { !it.isEmpty() } + "" + lines.subList(buildSuccessfulLineIndex, lines.size())
        return normalized.join("\n")
    }

More text.

      Blocks
    can

  have
    blank
      lines.
-- gofmt --
Text.

	A tab-indented
	(no, not eight-space indented)
	code block and haiku.

More text.

	One space
	 is
	  enough
	   to
	    start
	     a
	      block.

More text.

	    Blocks
	  can

	have
	  blank
	    lines.
-- markdown --
Text.

	A tab-indented

        failure.assertHasLineNumber(lines + 3)
        failure.assertHasCause("There was an error while evaluating a component metadata rule for org.test:projectA:1.0.")
        failure.assertHasCause("No signature of method: WrongRule.foo() is applicable for argument types: () values: []")
    }

    def "produces sensible error for invalid component metadata rule" () {
        def lines = buildFile.readLines().size()
        buildFile << """

  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) {

	if m := loc.Mapping; m != nil && re.MatchString(m.File) {
		return nil
	}
	var lines []Line
	for _, ln := range loc.Line {
		if fn := ln.Function; fn != nil {
			if re.MatchString(fn.Name) || re.MatchString(fn.Filename) {
				continue
			}
		}
		lines = append(lines, ln)
	}
	return lines
}

// matchedLines returns the lines in the location that match

    String separator = System.getProperty("line.separator");
    sink.writeLines(lines);

    assertContainsExpectedLines(separator);
  }

  public void testWriteLines_specificSeparator() throws IOException {
    String separator = "\r\n";
    sink.writeLines(lines, separator);

    assertContainsExpectedLines(separator);
  }

        println "-> CHECKING: $progressContent"
        def lines = progressContent
        def startIndex = lines.indexOf("[START " + operation + "]")
        if (startIndex == -1) {
            return false
        }
        lines = lines[startIndex..<lines.size()]
        lines = lines[0..lines.indexOf("[END " + operation + "]")]
        lines.size() >= 2
    }

    @Deprecated

                }
                if (newDaemons > 1) {
                    return true
                }
                def lines = gradle.standardOutput.readLines()
                dataFile << lines[lines.findLastIndexOf { it.startsWith "Starting" }]
                dataFile << "  " + lines[lines.findLastIndexOf { it.contains "Total time:" }]
                dataFile << "\n"
            }
        } finally {

                return false;
            }
        }
        return true;
    }

    /**
     * Finds all the lines in the actual line that match any line in the expected list.
     *
     * @return a map of expected line index to a list of all actual line indices that match the expected line
     */
    private static Map<Integer, List<Integer>> findMatchingLines(List<String> expectedLines, List<String> actualLines) {