if (42 == 42) {
                return 0;
              }
              return -1;
            }"""),
    ]

    List<SourceFile> headerFiles = []

    @Override
    SourceElement getHeaders() {
        return ofElements(sum.headers)
    }

    @Override
    SourceElement getSources() {
        return ofElements(sum.sources, sumTest.sources)
    }

    @Override

        given:
        httpBuildCacheServer.cacheDir.createDir("redirect")
        httpBuildCacheServer.addResponder { req, res ->
            if (!req.requestURI.startsWith("/redirect")) {
                res.setHeader("location", "redirect$req.requestURI")
                res.setStatus(307)
                res.writer.close()
                false
            } else {
                true
            }
        }

    }

    @Override
    public NativePlatform getTargetPlatform() {
        return targetPlatform;
    }

    @Override
    public FileCollection getHeaderDirs() {
        return library.getHeaders().getSourceDirectories();
    }

    protected FileCollection createFileCollection(File file, String fileCollectionDisplayName, String fileDescription) {

                if (StringUtil.isBlank(responseContentType)) {
                    response.setHeader("Content-Type", "application/json");
                } else {
                    response.setHeader("Content-Type", responseContentType);
                }
                CopyUtil.copy(in, out);
            } catch (final ClientAbortException e) {

                parameters.getPrefixHeaderFile().set(prefixHeaderFile);
            }
        });
    }

    @Input
    public String getHeader() {
        return header;
    }

    public void setHeader(String header) {
        this.header = header;
    }

    @OutputFile
    public File getPrefixHeaderFile() {
        return prefixHeaderFile;
    }

        public abstract ConfigurableFileCollection getSources();

        public abstract ConfigurableFileCollection getTests();

        public abstract ConfigurableFileCollection getHeaders();
    }

	attrs := request.GetAttributes()

	// Determine whether to allow or deny the request.
	allow := false
	checkHeaderValue, contains := attrs.GetRequest().GetHttp().GetHeaders()[checkHeader]
	if contains {
		allow = checkHeaderValue == allowedValue
	} else {
		allow = attrs.Source != nil && strings.HasSuffix(attrs.Source.Principal, "/sa/"+*serviceAccount)
	}

	if allow {

func (c *Config) fillDefaults() error {
	c.checkRedirect = checkRedirectFunc(c.Request)
	c.timeout = common.GetTimeout(c.Request)
	c.count = common.GetCount(c.Request)
	c.headers = common.GetHeaders(c.Request)
	c.hboneHeaders = common.ProtoToHTTPHeaders(c.Request.Hbone.GetHeaders())

	// Extract the host from the headers and then remove it.
	c.hostHeader = c.headers.Get(hostHeader)
	c.headers.Del(hostHeader)

		})
	}
}

func routeBasedOnJWTClaimKey(vs *v1alpha3.VirtualService) string {
	for _, httpRoute := range vs.GetHttp() {
		for _, match := range httpRoute.GetMatch() {
			for key := range match.GetHeaders() {
				if jwt.ToRoutingClaim(key).Match {
					return key
				}
			}
			for key := range match.GetWithoutHeaders() {
				if jwt.ToRoutingClaim(key).Match {
					return key
				}
			}
		}

                    def auth = super.validateRequest(req, new ServletResponseHttpWrapper(res), mandatory)
                    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