}

    @Override
    public String getMethod() {
        return handler.getMethod();
    }

    @Override
    public void assertCanWait() throws IllegalStateException {
        lock.lock();
        try {
            owner.assertCanWait();
            if (!autoRelease && !started) {

/**
 * Some action that must be met before it is legal to wait for an incoming request.
 */
interface WaitPrecondition {
    /**
     * Must be called under lock.
     */
    void assertCanWait() throws IllegalStateException;

    }

    @Override
    public WaitPrecondition getWaitPrecondition() {
        return this;
    }

    @Override
    public void assertCanWait() throws IllegalStateException {
        lock.lock();
        try {
            previous.assertCanWait();
            if (notReceived.isEmpty()) {
                // Have received all requests so downstream can wait.
                return;
            }

        }
        SendPartialResponseThenBlock block = new SendPartialResponseThenBlock(lock, timeout, new WaitPrecondition() {
            @Override
            public void assertCanWait() throws IllegalStateException {
                ExpectMethod.this.precondition.assertCanWait();
            }
        }, content);
        replaceBody(block, block);
        return this;
    }

    @Override

        }
    }

    @Override
    public WaitPrecondition getWaitPrecondition() {
        return () -> {
            for (TrackingHttpHandler handler : expected) {
                handler.getWaitPrecondition().assertCanWait();
            }
        };
    }

    @Override
    public void cancelBlockedRequests() {
        lock.lock();
        try {
            if (current != null) {

        }
        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.");
            }

            long now = clock.getCurrentTime();

            httpExchange.sendResponseHeaders(200, 0);
        }
    }

    private class MustBeRunning implements WaitPrecondition {
        @Override
        public void assertCanWait() throws IllegalStateException {
            lock.lock();
            try {
                if (!running) {
                    throw new IllegalStateException("Cannot wait as the server is not running.");