/**
     * The tag used for the raw model without profile activation
     */
    ModelCacheTag<ModelData> RAW = new ModelCacheTag<ModelData>() {

        @Override
        public String getName() {
            return "raw";
        }

        @Override
        public Class<ModelData> getType() {
            return ModelData.class;
        }
    };

    /**

    private final Iterable<File> classpath;
    private final Iterable<File> modulePath;
    private final List<String> jvmArgs;
    private final Map<String, String> environment;

    DefaultTestTaskForkOptions(
        File workingDir,
        String executable,
        int javaMajorVersion,
        Iterable<File> classpath,
        Iterable<File> modulePath,
        List<String> jvmArgs,
        Map<String, String> environment

        List<File> modulePath = new ArrayList<>();

        if (runAsModule) {
            modulePath.addAll(workerMainClassPath);
        } else {
            classpath.addAll(workerMainClassPath);
        }
        modulePath.addAll(applicationModulePath);
        classpath.addAll(applicationClasspath);

    }

    public void setClasspath(Iterable<String> classpath) {
        this.classpath = classpath;
    }

    public void setModulePath(Iterable<String> modulePath) {
        this.modulePath = modulePath;
    }

    public void setScriptRelPath(String scriptRelPath) {
        this.scriptRelPath = scriptRelPath;
    }

    public void setAppNameSystemProperty(String appNameSystemProperty) {

    }

    private IvyFileModule createModule(String organisation, String module, String revision) {
        def modulePath = getDirPath(organisation, module, revision)
        def moduleDir = rootDir.file(modulePath)
        return new IvyFileModule(ivyFilePattern, artifactFilePattern, modulePath, moduleDir, organisation, module, revision, m2Compatible)
    }

	}
}

func (l *loggingRepo) ModulePath() string {
	return l.r.ModulePath()
}

func (l *loggingRepo) CheckReuse(ctx context.Context, old *codehost.Origin) (err error) {
	defer func() {
		logCall("CheckReuse[%s]: %v", l.r.ModulePath(), err)
	}()
	return l.r.CheckReuse(ctx, old)
}

		}
		return ce, nil
	}

	modulePath, err := getModulePath(c.dir, key.moduleKey)
	if err != nil {
		return nil, err
	}
	// Materialize the Wasm module into a local file. Use checksum as name of the module.
	if err := os.WriteFile(modulePath, wasmModule, 0o644); err != nil {
		return nil, err
	}

	ce := cacheEntry{
		modulePath:      modulePath,
		last:            time.Now(),

        return Collections.emptyList();
    }

    /**
     * Returns a list of distribution modules that the test worker requires on the application modulepath if it runs as a module.
     * These dependencies are loaded from the Gradle distribution.
     *
     * Application classes specified by {@link WorkerProcessBuilder#sharedPackages} are

	x.stab.Lookup("")
	x.pkgpath = x.stab.Lookup(pkgpath)
	x.pkgname = x.stab.Lookup(pkgname)
	x.modpath = x.stab.Lookup(modulepath)
	io.WriteString(x.h, pkgpath)
	io.WriteString(x.h, pkgname)
	io.WriteString(x.h, modulepath)
	return x, nil
}

func h32(x uint32, h hash.Hash, tmp []byte) {
	tmp = tmp[:0]
	tmp = append(tmp, 0, 0, 0, 0)
	binary.LittleEndian.PutUint32(tmp, x)
	h.Write(tmp)
}

type funcDesc struct {

package configstore

import (
	"bytes"
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"

	"golang.org/x/telemetry/internal/telemetry"
)

const (
	ModulePath     = "golang.org/x/telemetry/config"
	configFileName = "config.json"
)

// needNoConsole is used on windows to set the windows.CREATE_NO_WINDOW
// creation flag.
var needNoConsole = func(cmd *exec.Cmd) {}