wait.PollImmediate(500*time.Millisecond, wait.ForeverTestTimeout, func() (done bool, err error) {
		if waiting := target.Waiting(); waiting {
			waitingGot = true
			return true, nil
		}
		return false, nil
	})
	// verify that the waitgroup is in 'Waiting' mode
	if !waitingGot {
		t.Errorf("expected to be in waiting")
	}

	// we should not allow any new request to use this waitgroup any longer

[19511] [INFO] Started server process [19511]
[19511] [INFO] Waiting for application startup.
[19511] [INFO] Application startup complete.
[19513] [INFO] Started server process [19513]
[19513] [INFO] Waiting for application startup.
[19513] [INFO] Application startup complete.
[19514] [INFO] Started server process [19514]
[19514] [INFO] Waiting for application startup.
[19514] [INFO] Application startup complete.

	runtime_notifyListWait(&c.notify, t)
	c.L.Lock()
}

// Signal wakes one goroutine waiting on c, if there is any.
//
// It is allowed but not required for the caller to hold c.L
// during the call.
//
// Signal() does not affect goroutine scheduling priority; if other goroutines
// are attempting to lock c.L, they may be awoken before a "waiting" goroutine.
func (c *Cond) Signal() {
	c.checker.check()

        thrown(UnexpectedBuildFailure)
    }

    def "output parsing with info logging after 'waiting for changes' line"() {
        given:
        def sampleTest = testCase()
        def gradleHandle = setupStubs(sampleTest)
        gradleHandle.getStandardOutput() >> '''
:sometask

BUILD SUCCESSFUL in 1s

Waiting for changes to input files... (ctrl-d then enter to exit)

            unexpectedPath = path;
        }
        return new UnexpectedRequestFailure(requestMethod, path, context);
    }

    /**
     * Signals that a timeout occurred waiting to handle the given request.
     *
     * @return A response to return to the client
     */
    public ResponseProducer timeout(String requestMethod, String path, String waitingFor, String context) {

                }
            }
        }

        then:
        poll {
            assert signal.waiting
        }

        when:
        signal.trigger()

        then:
        poll {
            assert signalCount.get() == 1
            assert signal.waiting
        }

        when:
        signal.trigger()

        then:
        poll {

 * ordinary tests.
 *
 * <p>Failure of the expected event to occur within an implementation-defined "reasonable" time
 * period or an interrupt while waiting for the expected event will result in a {@link
 * RuntimeException}.
 *
 * <p>Here's an example that tests a {@code finalize} method:
 *
 * <pre>{@code
 * final CountDownLatch latch = new CountDownLatch(1);

        // other builds in the tree. The thread will signal the other threads and then stop running as a worker. At this point in time, work will be ready to start but all the (other) workers will
        // still be waiting. A short time later, the workers will wake up and start running the work.

			p := ps[ev.P]
			if err := checkRunning(p, g, ev, false); err != nil {
				return err
			}
			g.state = gWaiting
			g.evStart = nil
			p.g = 0

			gs[ev.G] = g
			ps[ev.P] = p
		case EvGoSysExit:
			g := gs[ev.G]
			if g.state != gWaiting {
				return fmt.Errorf("g %d is not waiting during syscall exit (time %d)", ev.G, ev.Ts)
			}
			g.state = gRunnable
			g.ev = ev

			gs[ev.G] = g

        toolingApi.requireDaemons()
        def outInstance = System.out
        def errInstance = System.err
        def inInstance = System.in
        def handle = sync.expectAndBlock("waiting")

        buildFile << """
            ${sync.callFromBuild("waiting")}
            task hey
        """

        when:
        GradleProject model = toolingApi.withConnection { ProjectConnection connection ->