assertRequest(httpStub, request)
                    if (expectation.run) {
                        println("This expectation for the request [${request.method} :${request.pathInfo}] was already handled - skipping")
                        return
                    }
                    if (!((Request) request).isHandled()) {
                        expectation.atomicRun.set(true)
                        action.handle(request, response)

            modelsCreated(new ModelRequestExpectation(path, modelNames))
        }

        void modelsCreated(ModelRequestExpectation expectation) {
            projectsConfigured(expectation.path)
            runsTasks = false
            loadsOnStore = false
            models.add(expectation)
        }

        void modelsQueriedAndNotPresent(String... paths) {
            for (path in paths) {

            storageObject.getContentType(),
            storageObject.getEtag(),
            null // we cannot use md5 instead of sha1 here because cache will get corrupted due to its expectation of sha1 hashes
        );
    }

    private ResourceMapper() {
        throw new AssertionError("No instances");
    }

package ld

import (
	"os"
	"os/exec"
	"path/filepath"
	"syscall"
)

const syscallExecSupported = true

// execArchive invokes the archiver tool with syscall.Exec(), with
// the expectation that this is the last thing that takes place
// in the linking operation.
func (ctxt *Link) execArchive(argv []string) {
	var err error
	argv0 := argv[0]
	if filepath.Base(argv0) == argv0 {

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    @Requires(value = IntegTestPreconditions.NotParallelExecutor, reason = """
Don't run in parallel mode, as the expectation for the setup build are incorrect and running in parallel
does not really make any difference to the coverage
""")
    def "runs tasks in different projects in parallel by default"() {
        server.start()

            val bufferedRequestBody = exchange.createRequestBody(request, true).buffer()
            requestBody.writeTo(bufferedRequestBody)
          } else {
            // Write the request body if the "Expect: 100-continue" expectation was met.
            val bufferedRequestBody = exchange.createRequestBody(request, false).buffer()
            requestBody.writeTo(bufferedRequestBody)
            bufferedRequestBody.close()
          }
        } else {

        }

        HttpExpectOne expectation = new HttpExpectOne(action, methods, path)
        return addOneRequestExpecation(path, matchPrefix, methods, action, expectation)
    }

    @CompileStatic
    HttpResourceInteraction forbid(String path, boolean matchPrefix, Collection<String> methods, Action action) {
        HttpForbidOne expectation = new HttpForbidOne(action, methods, path)

			//
			// According to
			// http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.20
			// Expect header is always of form:
			//
			//   Expect       =  "Expect" ":" 1#expectation
			//   expectation  =  "100-continue" | expectation-extension
			//
			// So it safe to assume that '100-continue' is what would
			// be sent, for the time being keep this work around.

     *
     * This method will emit a detailed deprecation method with suggestions if the usage is inconsistent.  It will then attempt to mutate
     * the usage to match the expectation.  If the usage cannot be mutated, it will throw an exception.
     *
     * Does <strong>NOT</strong> check anything to do with deprecated usage.
     *

   * implementation, because {@code map.get()} returns a view collection that changes in the course
   * of a call to {@code remove()}. Thus, the expectation doesn't hold that {@code map.remove(x)}
   * returns the same value which {@code map.get(x)} did immediately beforehand.
   */
  @Override
  public void testRemove() {
    final Map<String, Collection<Integer>> map;