/**
         * Get the total memory of this category in bytes.
         *
         * @return the total memory of this category in bytes
         */
        long getTotal();

        /**
         * Get the free memory of this category in bytes.
         *
         * @return the free memory of this category in bytes
         */
        long getFree();
    }

    /**

    }

    public interface Result {

        boolean isEnabled();

        boolean isLocalEnabled();

        boolean isRemoteEnabled();

        @Nullable
        BuildCacheDescription getLocal();

        @Nullable
        BuildCacheDescription getRemote();

        interface BuildCacheDescription {

            /**
             * The class name of the DSL configuration type.
             *

        List<PluginExecution> executions = plugin.getExecutions();

        PluginExecution execution = executions.get(0);

        String g0 = execution.getGoals().get(0);

        assertEquals("plexus:runtime", g0);

        configuration = execution.getDelegate().getConfiguration();

        assertEquals(

	"k8s.io/kube-openapi/pkg/validation/spec"
)

var intOrStringFormat = intstr.IntOrString{}.OpenAPISchemaFormat()

func isExtension(schema *spec.Schema, key string) bool {
	v, ok := schema.Extensions.GetBool(key)
	return v && ok
}

func isXIntOrString(schema *spec.Schema) bool {
	// built-in types have the Format while CRDs use extension
	// both are valid, checking both

        Map<String, List<String>> goals = new HashMap<>();
        lifecycle.phases().forEach(phase -> phase.plugins()
                .forEach(plugin -> plugin.getExecutions().forEach(exec -> exec.getGoals()
                        .forEach(goal -> goals.computeIfAbsent(phase.name(), n -> new ArrayList<>())
                                .add(plugin.getGroupId() + ":" + plugin.getArtifactId() + ":" + plugin.getVersion()

	if rt == nil {
		return madmin.TimedErrStats{}
	}
	errCounts := make(map[string]int)
	for k, v := range rt.ErrCounts {
		errCounts[k] = v
	}
	minuteTotals := rt.LastMinute.getTotal()
	hourTotals := rt.LastHour.getTotal()
	return madmin.TimedErrStats{
		LastMinute: madmin.RStat{
			Count: float64(minuteTotals.N),
			Bytes: minuteTotals.Size,
		},
		LastHour: madmin.RStat{
			Count: float64(hourTotals.N),

		return 0
	}
	_, _, _ = util.GenCSR(certOptions)
	return 1
}

func fuzzedCertChain(f *fuzz.ConsumeFuzzer) ([][]*x509.Certificate, error) {
	certChain := [][]*x509.Certificate{}
	withPkixExtension, err := f.GetBool()
	if err != nil {
		return certChain, err
	}
	if withPkixExtension {
		ids := []util.Identity{}
		err := f.GenerateStruct(&ids)
		if err != nil {
			return certChain, err
		}

    }

    public void compilerProbeArgs(String... args) {
        this.compilerProbeArgs.addAll(Arrays.asList(args));
    }

    @Nullable
    @Override
    public GccCommandLineToolConfigurationInternal getTool(ToolType toolType) {
        return tools.get(toolType);
    }

    public Collection<GccCommandLineToolConfigurationInternal> getTools() {
        return tools.values();
    }

    /**
     * Returns the local directory cache configuration.
     */
    DirectoryBuildCache getLocal();

    /**
     * Executes the given action against the local configuration.
     *
     * @param configuration the action to execute against the local cache configuration.
     */

        throw failure();
    }

    @Override
    public CommandLineToolSearchResult locateTool(ToolType compilerType) {
        return this;
    }

    @Override
    public File getTool() {
        throw new UnsupportedOperationException();
    }

    @Override
    public SystemLibraries getSystemLibraries(ToolType compilerType) {
        return new EmptySystemLibraries();
    }