"> one-1.2.pom", "> two-1.2.pom"
            )
        }

        when:
        metaData.releaseAll()
        getM1Pom.waitUntilBlocked()
        getM2Pom.waitUntilBlocked()

        then:
        ConcurrentTestUtil.poll {
            outputContainsProgress(build,
                "> :resolve > Resolve dependencies of :compile",

            }
        } finally {
            lock.unlock();
        }
        exchange.getResponseBody().write(content, 1024, content.length - 1024);
    }

    @Override
    public void waitUntilBlocked() {
        lock.lock();
        try {
            precondition.assertCanWait();
            if (released) {
                throw new IllegalStateException("Response has already been released.");
            }

        this.precondition = precondition;
        return this;
    }

    @Override
    public void waitUntilBlocked() {
        if (blockingRequest == null) {
            throw new IllegalStateException("This request is not expected to block.");
        }
        blockingRequest.waitUntilBlocked();
    }

    @Override
    public void release() {
        if (blockingRequest == null) {

            start {
                succeeds("a")
                instant.aDone
                succeeds("b")
            }
            request1.waitUntilBlocked()
            instant.aBlocked
            request1.release()
            request2.waitUntilBlocked()
            request2.release()
        }
        server.stop()

        then:
        instant.aDone > instant.aBlocked
    }

        }
    }

    public interface ThreadHandle {
        ThreadHandle waitFor();

        boolean waitUntil(Date expiry);

        boolean isCurrentThread();

        void waitUntilBlocked();
    }

    public interface ClockTick {
        ClockTick hasParticipants(int count);
    }

    private static class ClockTickImpl implements ClockTick {
        private final int number;

                .forTasks("help")
                .withCancellationToken(tokenSource.token())
                .addProgressListener(events)
                .run(handler)
            downloadHandle.waitUntilBlocked()
            tokenSource.cancel()
            handler.finished()
            downloadHandle.release()
        }

        then:
        handler.assertFailedWith(BuildCancelledException)

     */
    public interface BlockingRequest extends ExpectedRequest {
        /**
         * Waits for the request to be received and blocked.
         */
        void waitUntilBlocked();

        /**
         * Unblock the request.
         */
        void release();
    }

    /**
     * Allows the test to synchronise with and unblock requests.
     */