});
        }
        if (reports.getCsv().getRequired().get()) {
            antBuilder.invokeMethod("csv", new Object[]{
                ImmutableMap.<String, Object>of("destfile", reports.getCsv().getOutputLocation().getAsFile().get())
            });
        }
    }

        return (DirectoryReport)getByName("html");
    }

    @Override
    public SingleFileReport getXml() {
        return (SingleFileReport)getByName("xml");
    }

    @Override
    public SingleFileReport getCsv() {
        return (SingleFileReport)getByName("csv");
    }

     */
    @Internal
    SingleFileReport getXml();

    /**
     * The JaCoCo (single file) CSV report
     *
     * @return The JaCoCo (single file) CSV report
     */
    @Internal
    SingleFileReport getCsv();

 * <pre>
 * class MyTask implements Reporting&lt;MyReportContainer&gt; {
 *     // implementation
 * }
 *
 * interface MyReportContainer extends ReportContainer&lt;Report&gt; {
 *     Report getHtml();
 *     Report getCsv();
 * }
 * </pre>
 * <p>
 * The reporting aspects of such a task can be configured as such:
 * </p>
 * <pre>
 * task my(type: MyTask) {
 *     reports {
 *         html.required = true

	idx := len(z) - ztailsize
	n := get2s(z[idx+10:])
	idx = get4s(z[idx+16:])

	for i := 0; i < n; i++ {
		// See time.loadTzinfoFromZip for zip entry layout.
		if get4s(z[idx:]) != zcheader {
			break
		}
		meth := get2s(z[idx+10:])
		size := get4s(z[idx+24:])
		namelen := get2s(z[idx+28:])
		xlen := get2s(z[idx+30:])
		fclen := get2s(z[idx+32:])
		off := get4s(z[idx+42:])
		zname := z[idx+46 : idx+46+namelen]

            processEnv["${ENV_VARIABLES}"] = [:]
            System.getenv().each { key, value ->
                processEnv["${ENV_VARIABLES}"][key] = value
            }

            new File('${TextUtil.normaliseFileSeparators(processJsonFile.absolutePath)}').text = groovy.json.JsonOutput.toJson(processEnv)
        """
    }

    interface Option {
        String getDsl();

        void verify(Map processEnv);
    }

					failed = true
				}
				s = s[1:]
			}
			chunk = chunk[1:]
		}
	}
	if failed {
		return "", false, nil
	}
	return s, true, nil
}

// getEsc gets a possibly-escaped character from chunk, for a character class.
func getEsc(chunk string) (r rune, nchunk string, err error) {
	if len(chunk) == 0 || chunk[0] == '-' || chunk[0] == ']' {
		err = ErrBadPattern
		return
	}
	if chunk[0] == '\\' {

	// or if it's empty we just use a default in /tmp
	coverageFile = os.Getenv("KUBE_COVERAGE_FILE")
	if coverageFile == "" {
		coverageFile = "/tmp/k8s-" + name + ".cov"
	}
	fmt.Println("Dumping coverage information to " + coverageFile)

	flushInterval := 5 * time.Second
	requestedInterval := os.Getenv("KUBE_COVERAGE_FLUSH_INTERVAL")
	if requestedInterval != "" {

	}
	return s[:i], i
}

// Getenv retrieves the value of the environment variable named by the key.
// It returns the value, which will be empty if the variable is not present.
// To distinguish between an empty value and an unset value, use [LookupEnv].
func Getenv(key string) string {
	testlog.Getenv(key)
	v, _ := syscall.Getenv(key)
	return v
}

package org.gradle.internal.cc.impl.inputs.undeclared

abstract class EnvVariableRead extends BuildInputRead {
    static EnvVariableRead getEnv(String name) {
        return new EnvVariableRead() {
            @Override
            String getKotlinExpression() {
                return "System.getenv(\"$name\")"
            }
        }
    }

    static EnvVariableRead getEnvGet(String name) {
        return new EnvVariableRead() {