* limitations under the License.
 */

package org.gradle.test.fixtures.server.http;

import com.sun.net.httpserver.HttpExchange;

import java.io.IOException;

interface ResponseProducer {
    default boolean isFailure() {
        return false;
    }

    /**
     * Called to handle a request. Is *not* called under lock.
     */

            try {
                ResponseProducer responseProducer = selectProducer(id, httpExchange);
                System.out.printf("[%d] sending response for %s%n", id, outcome.getDisplayName());
                if (!responseProducer.isFailure()) {
                    responseProducer.writeTo(id, httpExchange);
                } else {
                    Throwable failure = responseProducer.getFailure();

    private final Duration timeout;
    private final Lock lock;

    private ResponseProducer producer = new ResponseProducer() {
        @Override
        public void writeTo(int requestId, HttpExchange exchange) throws IOException {
            responseBody.writeTo(requestId, exchange);
        }
    };
    private ResponseProducer responseBody = new SendFixedContent(200, "hi");
    private BlockingRequest blockingRequest;

        } finally {
            lock.unlock();
        }
    }

    @Nullable
    @Override
    public ResponseProducer selectResponseProducer(int id, HttpExchange exchange) {
        lock.lock();
        try {
            if (current != null) {
                ResponseProducer producer = current.selectResponseProducer(id, exchange);
                if (producer != null) {
                    return producer;

        return failure != FailureType.None;
    }

    /**
     * Signals that an unexpected request was received.
     *
     * @return A response to return to the client
     */
    public ResponseProducer unexpectedRequest(String requestMethod, String path, String context) {
        if (failure == FailureType.None) {
            failure = FailureType.UnexpectedRequest;
            unexpectedMethod = requestMethod;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.test.fixtures.server.http;

interface Failure extends ResponseProducer {

        String path = exchange.getRequestURI().getPath().substring(1);
        ResourceHandlerWrapper handler = selectPending(notReceived, path);
        return handler != null;
    }

    @Override
    public ResponseProducer selectResponseProducer(int id, HttpExchange exchange) {
        ResourceHandlerWrapper handler;
        lock.lock();
        try {
            if (notReceived.isEmpty()) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.test.fixtures.server.http;

interface ResourceHandler extends ResponseProducer {
    /**
     * Returns the method for this handler.
     */
    String getMethod();

    /**
     * Returns the path for this handler.
     */
    String getPath();

     *
     * @return null when this handler is not expecting any further requests.
     */
    @Nullable
    ResponseProducer selectResponseProducer(int id, HttpExchange exchange);

    boolean expecting(HttpExchange exchange);

    /**

 * limitations under the License.
 */

package org.gradle.test.fixtures.server.http;

import com.sun.net.httpserver.HttpExchange;

abstract class AbstractFailure implements ResponseProducer, Failure {
    private final RuntimeException failure;

    public AbstractFailure(RuntimeException failure) {
        this.failure = failure;
    }

    @Override
    public boolean isFailure() {