List<String> result = new ArrayList<>();
        List<String> lines = output.getLines();
        int i = 0;
        while (i < lines.size()) {
            String line = lines.get(i);
            if (line.contains(DaemonStartupMessage.STARTING_DAEMON_MESSAGE)) {
                // Remove the "daemon starting" message
                i++;
            } else if (line.contains(DaemonStateCoordinator.DAEMON_WILL_STOP_MESSAGE)) {

    // 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:

sschepens <******@****.***> 1717506007 -0300

public class ExecutionGraph {
    // Execution 1,2,3, starting from 1
    int index;
    String title;
    List<Line> data;

    public ExecutionGraph(int index, Line... lines) {
        this.index = index;
        this.title = "Execution " + index + " (ms)";
        this.data = Arrays.asList(lines);
    }

    String getData() {
        return JsonOutput.toJson(data);
    }

    String getTicks() {

		key.addr -= l.Mapping.Start
		key.mappingID = l.Mapping.ID
	}
	lines := make([]string, len(l.Line)*3)
	for i, line := range l.Line {
		if line.Function != nil {
			lines[i*2] = strconv.FormatUint(line.Function.ID, 16)
		}
		lines[i*2+1] = strconv.FormatInt(line.Line, 16)
		lines[i*2+2] = strconv.FormatInt(line.Column, 16)
	}
	key.lines = strings.Join(lines, "|")
	return key
}

type locationKey struct {

				// Write increasing prefixes of that line.
				for j := 0; j < x; j++ {
					w.Write(line[:j*2])
					w.Write([]byte{'\n'})
				}
				w.Flush()
			}
		})
	}
}

func BenchmarkRagged(b *testing.B) {
	var lines [8][]byte
	for i, w := range [8]int{6, 2, 9, 5, 5, 7, 3, 8} {
		// Build a line with w cells.
		lines[i] = bytes.Repeat([]byte("a\t"), w)
	}
	for _, h := range [...]int{10, 100, 1000} {

            final String[] lines = value.split("[\r\n]");
            for (final String line : lines) {
                if (StringUtil.isNotBlank(line)) {
                    final int pos = line.indexOf('=');
                    if (pos == 0) {
                        paramMap.put("unknown." + (unknownKey + 1), line.substring(pos + 1).trim());
                        unknownKey++;

        static Lookup find(List<String> lines, String anchor) {
            boolean inJavadoc
            List<String> javadoc = []
            for (line in lines) {
                if (line.trim().startsWith("/**")) {
                    inJavadoc = true
                    javadoc.clear()
                }
                if (inJavadoc) {
                    javadoc << line
                }

            throw new GradleException(prepareMessage(output, startupArgs));
        }
        String[] lines = output.split("\n");
        //Assuming that the diagnostics were printed out to the last line. It's not bullet-proof but seems to be doing fine.
        String lastLine = lines[lines.length - 1];
        return startupCommunication.readDiagnostics(lastLine);
    }

	// interior blank lines to a single blank line.
	n := 0
	for _, line := range lines {
		if line != "" || n > 0 && lines[n-1] != "" {
			lines[n] = line
			n++
		}
	}
	lines = lines[0:n]

	// Add final "" entry to get trailing newline from Join.
	if n > 0 && lines[n-1] != "" {
		lines = append(lines, "")
	}

	return strings.Join(lines, "\n")
}