/**
     * Returns the header and footer of the html template as a pair.
     */
    fun load(): Pair<String, String> {
        val template = readHtmlTemplate()
        val headerEnd = template.indexOf(modelLine)
        require(headerEnd > 0) {
            "Invalid configuration cache report template!"
        }
        val header = template.substring(0, headerEnd)

    protected abstract void generateReportFor(ProjectDetails project, T model);

    /**
     * Provides a means of printing a customizable footer section below the per-project details body
     * of the report.
     * <p>
     * By default, there is no footer information printed.
     *
     * @param modelsByProjectDetails information about the projects under report
     * @since 8.9
     */
    @Incubating

    def "accessing the task by path from containing project is safe"() {
        buildFile << """
            task foobar
            println "the name: " + tasks.getByPath(":foobar").name
        """

        when:
        run()

        then:
        output.contains "the name: foobar"
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects, evaluationDependsOn")

											<la:option value="14.12">14.12</la:option>
											<la:option value="14.13">14.13</la:option>
										</la:select>
									</div>
								</div>
							</div>
							<div class="card-footer">
								<button type="submit" class="btn btn-primary ${f:h(editableClass)}" name="upgradeFrom"
									value="<la:message key="labels.upgrade_start_button"/>"
								>
									<em class="fa fa-arrow-circle-right">

		{in: "foo\nbar", want: "foo\nbar"},
		{in: "foo\rbar", want: "foo\rbar"},
		{in: "foo\r\nbar", want: "foo\r\nbar"},

		// Different types of soft line-breaks.
		{in: "foo=\r\nbar", want: "foobar"},
		{in: "foo=\nbar", want: "foobar"},
		{in: "foo=\rbar", want: "foo", err: "quotedprintable: invalid hex byte 0x0d"},
		{in: "foo=\r\r\r \nbar", want: "foo", err: `quotedprintable: invalid bytes after =: "\r\r\r \n"`},

const (
	validTmpl    = "image: {{ .ImageRepository }}/pause:ver"
	validTmplOut = "image: registry.k8s.io/pause:ver"
	doNothing    = "image: registry.k8s.io/pause:ver"
	invalidTmpl1 = "{{ .baz }/d}"
	invalidTmpl2 = "{{ !foobar }}"
)

func TestParseTemplate(t *testing.T) {
	var tmplTests = []struct {
		name        string
		template    string
		data        interface{}
		output      string
		errExpected bool
	}{
		{

                process.waitForProcessOutput(System.out, System.err)
            """, enableIndy)

        when:
        configurationCacheFails(":help")

        then:
        failure.assertOutputContains("FOOBAR=$expectedEnvVar\nCWD=${cwd.path}")
        problems.assertFailureHasProblems(failure) {
            withProblem("Plugin class 'SomePlugin': external process started")
        }

        where:

    * So, to authenticate with our API, it sends a header `Authorization` with a value of `Bearer ` plus the token.
    * If the token contains `foobar`, the content of the `Authorization` header would be: `Bearer foobar`.

## **FastAPI**'s `OAuth2PasswordBearer`

**FastAPI** provides several tools, at different levels of abstraction, to implement these security features.

    // spaces and it breaks logic String.execute which splits the given string at spaces without
    // any options to escape the space.
    ShellScript baseScript = ShellScript.builder().printEnvironmentVariable('FOOBAR').printWorkingDir().writeTo(testDirectory, "test")

    def setup() {
        testDirectory.createDir(pwd)
    }


    static String getPwd() {
        return "tmp"
    }

		base:   "",
		pfx:    "/foo",
		expect: false,
	}, {
		base:   "/foo",
		pfx:    "/foo",
		expect: true,
	}, {
		base:   "/foo/bar",
		pfx:    "/foo",
		expect: true,
	}, {
		base:   "/foobar/qux",
		pfx:    "/foo",
		expect: false,
	}, {
		base:   "/foo/bar/bat/qux/zrb",
		pfx:    "/foo/bar/bat",
		expect: true,
	}}

	for _, tc := range cases {
		ret := hasPathPrefix(tc.base, tc.pfx)