given:
        runningStats.getBuildCount() >> 0

        when:
        tracker.execute(exec)

        then:
        1 * healthCheck.executeHealthCheck()
        1 * logger.info({ it ==~ /Starting build in new daemon \[memory: \d.*]/ })
    }

    def "executes health check on subsequent builds"() {
        given:
        runningStats.getBuildCount() >> 1

        when:
        tracker.execute(exec)

        userInput.readAndForwardText(event);
        handlePrompt(event);
    }

    private void handleUserInputRequestEvent() {
        startInput();
        paused = true;
    }

    private void handleUserInputResumeEvent(UserInputResumeEvent event) {
        if (!paused) {

     */
    int getMaxSegments();

    /**
     * Returns true if the path starting at the given offset satisfies this pattern.
     */
    boolean matches(String[] segments, int startIndex);

    /**
     * Returns true if the path starting at the given offset could be satisfy this pattern if it contained additional segments at the end.
     */

            run.executable 'does-not-exist'
        """

        when:
        fails taskName

        then:
        failure.assertThatCause(containsText("A problem occurred starting process"))
        failure.assertHasNoCause("could not be started because the command line exceed operating system limits.")

        where:
        method                    | taskName

		if !rc.desiredStateOfWorld.PodExistsInVolume(mountedVolume.PodName, mountedVolume.VolumeName, mountedVolume.SELinuxMountContext) {
			// Volume is mounted, unmount it
			klog.V(5).InfoS(mountedVolume.GenerateMsgDetailed("Starting operationExecutor.UnmountVolume", ""))
			err := rc.operationExecutor.UnmountVolume(
				mountedVolume.MountedVolume, rc.actualStateOfWorld, rc.kubeletPodsDir)
			if err != nil && !isExpectedError(err) {

	sink = make([][]byte, procs)

	for i := 0; i < procs; i++ {
		i := i
		go func() {
			for {
				sink[i] = make([]byte, 4<<10)
			}
		}()
	}
	// Increase the chance that we end up starting and stopping
	// mid-GC by only starting to trace after a few milliseconds.
	time.Sleep(5 * time.Millisecond)

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}

    int getLine();

    /**
     * The starting column on the selected line.
     * <p>
     * The column is <b>one-indexed</b>, i.e. the first column in the file is line number 1.
     * A non-positive value indicates that the column information is not available.
     *
     * @return the column
     */
    int getColumn();

    /**
     * The length of the selected content starting from specified column.

	// InstallTree is a top down hierarchy tree of dependencies where children must wait for the parent to complete
	// before starting installation.
	InstallTree = make(ComponentTree)
)

// buildInstallTree builds a tree from buildInstallTree where parents are the root of each subtree.
func buildInstallTree() {
	// Starting with root, recursively insert each first level child into each node.

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat

import org.junit.Test


class LinePreservingSubstringTest {

    @Test
    fun `given a range starting after the first line, it should return a substring prefixed by blank lines`() {
        val original = """
            // line 1
            // line 2
            buildscript {
                // line 4
            }

     * <p>
     * The line is <b>one-indexed</b>, i.e. the first line in the file is line number 1.
     *
     * @return the line number
     * @since 8.6
     */
    int getLine();

    /**
     * The starting column on the selected line.
     * <p>
     * The column is <b>one-indexed</b>, i.e. the first column in the file is column number 1.
     * A non-positive value indicates that the column information is not available.
     *