response.sendError(HttpServletResponse.SC_FORBIDDEN);
                return;
            }
        }

        FileOutputStream out = new FileOutputStream(file);
        try {
            if (_maxPutSize > 0) {
                int length = request.getContentLength();
                if (length > _maxPutSize) {
                    response.sendError(HttpServletResponse.SC_FORBIDDEN);

                        response.sendError(412, String.format("Precondition Failed: Expected User-Agent: '%s' but was '%s'", expectedUserAgent, receivedUserAgent))
                        return
                    }
                }
                if (expectedContentLength > -1) {
                    if (request.contentLength != expectedContentLength) {

	if wc.initialRev > 0 && forceInitialEvents {
		currentStorageRV, err := wc.watcher.getCurrentStorageRV(wc.ctx)
		if err != nil {
			wc.sendError(err)
			return
		}
		if uint64(wc.initialRev) > currentStorageRV {
			wc.sendError(storage.NewTooLargeResourceVersionError(uint64(wc.initialRev), currentStorageRV, int(wait.Jitter(1*time.Second, 3).Seconds())))
			return
		}
	}
	if forceInitialEvents {

        }

        if (connectionAuth.failed) {
            httpResponse.setHeader(HttpHeader.WWW_AUTHENTICATE.asString(), "basic realm=\"" + _loginService.getName() + '"')
            httpResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED)
            return Authentication.SEND_CONTINUE
        } else if (connectionAuth.user != null) {
           return connectionAuth.user
        } else {

        final RequestManager requestManager = ComponentUtil.getRequestManager();
        if (!requestManager.findUserBean(FessUserBean.class).map(user -> user.hasRoles(acceptedRoles)).orElse(Boolean.FALSE)) {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized access: " + request.getServletPath());
            return;
        }

        try {

                    if (!(auth instanceof Authentication.User)) {
                        res.setHeader(HttpHeader.WWW_AUTHENTICATE.asString(), "basic realm=\"" + _loginService.getName() + '"')
                        res.sendError(HttpServletResponse.SC_NOT_FOUND)
                        return Authentication.SEND_CONTINUE
                    }
                    return super.validateRequest(req, res, mandatory)
                }
            }

        def requestCounter = new AtomicInteger()
        httpBuildCacheServer.addResponder { req, res ->
            requestCounter.incrementAndGet()
            res.sendError(500)
            false
        }
        settingsFile << withHttpBuildCacheServer()

        when:
        withBuildCache().run("customTask", "customTask2")

        then:

                        KeyServer.this.fileHandler("/pks/lookup", KeyServer.this.keyFiles[keyId]).handle(request, response)
                    } else {
                        response.sendError(404, "not found")
                    }
                }
            }
        })
    }

    void registerPublicKey(PGPPublicKey key) {
        String longKeyId = toLongIdHexString(key.keyID)

            void handle(HttpServletRequest request, HttpServletResponse response) {
                response.sendError(304, 'Not Modified')
            }
        })

        then:
        fails 'retrieve'

        failure.assertHasCause('Response 304: Not Modified has no content!')
    }

        and:
        httpBuildCacheServer.addResponder { req, res ->
            if (req.method == "PUT") {
                assert req.getHeader("expect") == "100-continue"
                res.sendError(401)
                false
            } else {
                true
            }
        }

        when:
        executer.withStackTraceChecksDisabled()
        withBuildCache().run "jar"