boolean publishGradle() {
            gradle
        }
    }

    IvyFileModule(String ivyPattern, String artifactPattern, String modulePath, TestFile moduleDir, String organisation, String module, String revision, boolean m2Compatible) {
        this.modulePath = modulePath
        this.ivyPattern = ivyPattern
        this.artifactPattern = artifactPattern
        this.moduleDir = moduleDir

        args.add(Joiner.on(File.pathSeparatorChar).join(classpath));

        if (!modulePath.isEmpty()) {
            if (moduleVersion != null) {
                args.add("--module-version");
                args.add(moduleVersion);
            }
            args.add("--module-path");
            args.add(Joiner.on(File.pathSeparatorChar).join(modulePath));
        }
    }

    private void addSourceFiles() {

    }

    @Override
    protected TestFile getSha512File() {
        backingModule.getSha512File(file)
    }

    @Override
    String getPath() {
        return "${modulePath}/${backingArtifact.path}"
    }

    @Override
    TestFile getFile() {
        return backingArtifact.getFile()
    }

    @Override
    String getName() {
        return backingArtifact.name
    }

        startScriptGenerator.mainClassName = MAIN_CLASSNAME
        startScriptGenerator.defaultJvmOpts = DEFAULT_JVM_OPTS
        startScriptGenerator.classpath = CLASSPATH
        startScriptGenerator.modulePath = MODULE_PATH
        startScriptGenerator.scriptRelPath = SCRIPT_REL_PATH
        startScriptGenerator.appNameSystemProperty = APP_NAME_SYS_PROP
    }

     */
    Set<String> getClassesToCompile();

    List<File> getModulePath();

    void setModulePath(List<File> modulePath);

    default boolean annotationProcessingConfigured() {
        return !getAnnotationProcessorPath().isEmpty() && !getCompileOptions().getCompilerArgs().contains("-proc:none");
    }

        });

        // Note: here, type decides is artifact added to "build path" (for example during resolution)
        // and "build path" is intermediate data that is used to create actual Java classpath/modulepath
        // but to create those, proper filtering should happen via Type properties.
    }

    @Override
    public void addHandlers(Map<String, ArtifactHandler> handlers) {

// actually has one or more valid replacements.
type replacementRepo struct {
	repo versionRepo
}

var _ versionRepo = (*replacementRepo)(nil)

func (rr *replacementRepo) ModulePath() string { return rr.repo.ModulePath() }

func (rr *replacementRepo) CheckReuse(ctx context.Context, old *codehost.Origin) error {
	return fmt.Errorf("replacement repo")
}

echo location of your Java installation. 1>&2

goto fail

:execute
@rem Setup the command line

set CLASSPATH=$classpath
<% if ( mainClassName.startsWith('--module ') ) { %>set MODULE_PATH=$modulePath<% } %>

@rem Execute ${applicationName}

	if pp != p {
		t.Errorf("dec.PackagePath(): got %s want %s", pp, p)
	}
	ppn := dec.PackageName()
	if ppn != pn {
		t.Errorf("dec.PackageName(): got %s want %s", ppn, pn)
	}
	pmp := dec.ModulePath()
	if pmp != mp {
		t.Errorf("dec.ModulePath(): got %s want %s", pmp, mp)
	}
}

func TestMetaDataEncoderDecoder(t *testing.T) {
	// Test encode path.
	pp := "foo/bar/pkg"
	pn := "pkg"
	mp := "barmod"

                executable == expectedExecutable
                javaMajorVersion == expectedJavaVersion
                classpath.collect { new File(it as String) }.containsAll(expectedClasspath)
                modulePath == []
                jvmArgs.contains('-Dkey=value')
                environment.KEY == 'VALUE'
            }
            with(candidateClassFiles, List) {
                size() == 1