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

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

interface ResourceExpectation {
    ResourceHandler create(WaitPrecondition precondition);

        List<ResourceExpectation> expectations = new ArrayList<>();
        for (ExpectedRequest call : expectedCalls) {
            expectations.add((ResourceExpectation) call);
        }
        addNonBlockingHandler(expectations);
    }

    private void addNonBlockingHandler(final Collection<? extends ResourceExpectation> expectations) {

    public ExpectMaxNRequestsThenReleaseOne(Lock lock, int testId, Duration timeout, int maxConcurrent, WaitPrecondition previous, Collection<? extends ResourceExpectation> expectedRequests, Executor executor) {
        super(lock, testId, timeout, maxConcurrent, previous, expectedRequests, executor);
    }

    @Override

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

import com.sun.net.httpserver.HttpExchange;
import org.gradle.api.Action;

class ExpectMethodAndRunAction implements ResourceHandler, BlockingHttpServer.ExpectedRequest, ResourceExpectation {
    private final String method;
    private final String path;
    private final Action<? super HttpExchange> action;

    ExpectMethodAndRunAction(String method, String path, Action<? super HttpExchange> action) {

class ExpectAllRequestsThenReleaseAll extends ExpectMaxNConcurrentRequestsThenRelease {
    ExpectAllRequestsThenReleaseAll(Lock lock, int testId, Duration timeout, WaitPrecondition previous, Collection<? extends ResourceExpectation> expectations, Executor executor) {
        super(lock, testId, timeout, expectations.size(), previous, expectations, executor);
    }

    @Override

 */
class MaybeNConcurrentRequests extends ExpectMaxNConcurrentRequests {
    MaybeNConcurrentRequests(Lock lock, int testId, Duration timeout, int maxConcurrent, WaitPrecondition previous, Collection<? extends ResourceExpectation> expectedRequests) {
        super(lock, testId, timeout, maxConcurrent, previous, expectedRequests);
    }

    @Override
    public void assertComplete(Collection<Throwable> failures) throws AssertionError {

    private final Executor executor;

    public ExpectMaxNConcurrentRequestsThenRelease(Lock lock, int testId, Duration timeout, int maxConcurrent, WaitPrecondition previous, Collection<? extends ResourceExpectation> expectedRequests, Executor executor) {
        super(lock, testId, timeout, maxConcurrent, previous, expectedRequests);
        this.executor = executor;
    }

    @Override
    protected boolean isAutoRelease() {

    private final WaitPrecondition owner;
    private final boolean autoRelease;
    private boolean started;
    private boolean received;

    ResourceHandlerWrapper(Lock lock, ResourceExpectation expectation, WaitPrecondition owner, boolean isAutoRelease) {
        this.lock = lock;
        handler = expectation.create(this);
        this.owner = owner;
        this.autoRelease = isAutoRelease;
    }

    private final ExpectationState state = new ExpectationState();

    ExpectMaxNConcurrentRequests(Lock lock, int testId, Duration timeout, int maxConcurrent, WaitPrecondition previous, Collection<? extends ResourceExpectation> expectedRequests) {
        if (expectedRequests.size() < maxConcurrent) {
            throw new IllegalArgumentException("Too few requests specified.");
        }
        this.lock = lock;

import java.io.File;
import java.io.IOException;
import java.time.Duration;
import java.util.concurrent.locks.Lock;

class ExpectMethod implements ResourceHandler, BuildableExpectedRequest, ResourceExpectation, BlockingRequest {
    private final String method;
    private final String path;
    private final Duration timeout;
    private final Lock lock;

    private ResponseProducer producer = new ResponseProducer() {