<plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-clean-plugin</artifactId>
            <executions>
              <execution>
                <id>clean-target-dir</id>
                <goals>
                  <goal>clean</goal>
                </goals>
                <phase>prepare-package</phase>
                <configuration>

        assertEquals(1, executionPlan.size());
        MojoExecution mojoExecution = executionPlan.get(0);
        assertNotNull(mojoExecution);
        assertEquals(
                "org.apache.maven.plugins",
                mojoExecution.getMojoDescriptor().getPluginDescriptor().getGroupId());
        assertEquals(
                "maven-clean-plugin",

	// Diagnose common mistake: GOPATH==GOROOT.
	// This setting is equivalent to not setting GOPATH at all,
	// which is not what most people want when they do it.
	if gopath := cfg.BuildContext.GOPATH; filepath.Clean(gopath) == filepath.Clean(cfg.GOROOT) {
		fmt.Fprintf(os.Stderr, "warning: GOPATH set to GOROOT (%s) has no effect\n", gopath)
	} else {
		for _, p := range filepath.SplitList(gopath) {

cp stdout all.json

# clean the module cache, make sure that makes go mod download re-run git fetch, clean again
go clean -modcache
go mod download -x -json vcs-test.golang.org/git/hello.git@latest
stderr 'git( .*)* fetch'
go clean -modcache

# reuse go mod download vcstest/hello result

        packOp.result.archiveEntryCount == 5

        storeOp.details.cacheKey == cacheKey
        storeOp.details.archiveSize == archiveSize
        storeOp.result.stored

        when:
        succeeds("clean", "t")

        then:
        operations.none(BuildCacheRemoteStoreBuildOperationType)
        operations.none(BuildCacheRemoteLoadBuildOperationType)
        operations.none(BuildCacheLocalStoreBuildOperationType)

            // In the event that the main thread exits with an uncaught exception, stop processing
            // and clear out the run queue to unblock any running communication threads
            synchronized(this) {
                state = State.STOPPED;
                runQueue.clear();
            }

            if (System.getSecurityManager() != securityManager) {
                try {

    def snapshotModule = mavenHttpRepo.module('org.example', 'example', '1.0-SNAPSHOT').publish().allowAll()

    def setup() {
        requireOwnGradleUserHomeDir("test requires its own journal")
    }

    def "does not clean up resources and files that were recently used from caches"() {
        given:
        buildscriptWithDependency(snapshotModule)

        when:
        succeeds 'resolve'

        then:

            h2().text(String.format("Test: %s", testHistory.getDisplayName())).end();
            text(getReproductionInstructions(testHistory));
            p().text("Tasks: " + getTasks(testHistory)).end();
            p().text("Clean tasks: " + getCleanTasks(testHistory)).end();

            div().id("tooltip").end();

            addPerformanceGraphs();

            h3().text("Test details").end();
            table().classAttr("test-details");

    }

    def "custom clean targets are removed"() {
        given:
        buildFile << """
            apply plugin: 'base'

            task myTask {
                outputs.dir "external/output"
                outputs.file "customFile"
                outputs.dir "build/dir"
                doLast {}
            }

            clean {
                delete "customFile"

    }

    def "cleans up on close when clean up has not already occurred"() {
        def access = newAccess(OnDemand)

        when:
        access.open()
        access.close()

        then:
        1 * cleanupExecutor.cleanup()
        0 * _
    }

    def "does not clean up on close when clean up has already occurred"() {
        def access = newAccess(OnDemand)