)
                    )
                )
            )
        )
    }

    @Test
    fun `hash code takes container element types into account`() {

        assertThat(
            hashCodeFor(
                containerElements = listOf(
                    entry<TaskContainer, Delete>("clean")
                )
            ),

env GO111MODULE=off
[short] skip

# 'go install' with no arguments should clean up after go build
cd mycmd
go build
exists mycmd$GOEXE
go install
! exists mycmd$GOEXE

# 'go install mycmd' does not clean up, even in the mycmd directory
go build
exists mycmd$GOEXE
go install mycmd
exists mycmd$GOEXE

# 'go install mycmd' should not clean up in an unrelated current directory either
cd ..
cp mycmd/mycmd$GOEXE mycmd$GOEXE

        trusted.certificate,
      )
    assertThat(cleaner.clean(list(certB, certA), "hostname")).isEqualTo(
      list(certB, certA, trusted, selfSigned),
    )
    assertThat(cleaner.clean(list(certB, certA, trusted), "hostname")).isEqualTo(
      list(certB, certA, trusted, selfSigned),
    )
    assertThat(cleaner.clean(list(certB, certA, trusted, selfSigned), "hostname"))
      .isEqualTo(

        result.assertTaskSkipped ":compileJava"
    }

    def "clean doesn't get cached"() {
        withBuildCache().run "assemble"
        withBuildCache().run "clean"
        withBuildCache().run "assemble"
        when:
        withBuildCache().run "clean"
        then:
        executedAndNotSkipped ":clean"
    }

				t.Fatal(err)
			}
			if len(a.Files) != 3 || a.Files[2].Name != "diff" {
				t.Fatalf("%s: want three files, third named \"diff\"", file)
			}
			diffs := Diff(a.Files[0].Name, clean(a.Files[0].Data), a.Files[1].Name, clean(a.Files[1].Data))
			want := clean(a.Files[2].Data)
			if !bytes.Equal(diffs, want) {
				t.Fatalf("%s: have:\n%s\nwant:\n%s\n%s", file,
					diffs, want, Diff("have", diffs, "want", want))
			}
		})
	}

                'mediumCppMultiWithMacroIncludes',
                'bigCppMulti'
            ])
    ])
    def "clean assemble (native)"() {
        given:
        def iterations = runner.testProject in ['smallNative', 'smallCppApp', 'smallCppMulti'] ? 40 : null
        runner.tasksToRun = ["assemble"]
        runner.cleanTasks = ["clean"]
        runner.runs = iterations
        runner.warmUpRuns = iterations

        when:

#------------------------------------------------------------------------
# variables: files to clean
FILES_TO_CLEAN+=k8s-root-cert.pem \
                 k8s-root-cert.srl  \
                 k8s-root-key.pem root-ca.conf root-cert.csr root-cert.pem root-cert.srl root-key.pem
#------------------------------------------------------------------------
# clean
.PHONY: clean

clean: ## Cleans all the intermediate files and folders previously generated.

go list -x .
! stderr 'creating work dir'
stdout m
go list -m all
stdout m
! go list -x -export .
stderr '^go: creating work dir: \w+ '$GOTMPDIR

# 'go clean -cache' and 'go clean -modcache' should not fail.
go clean -x -cache
! stderr 'creating work dir'
go clean -x -modcache
! stderr 'creating work dir'

# 'go env' should not fail for specific variables.
# Without arguments, it needs to initialize a builder to load cgo flags, and

        public String id() {
            return Lifecycle.CLEAN;
        }

        @Override
        public Collection<Phase> phases() {
            return asList(
                    phase("pre-clean"),
                    phase(
                            "clean",
                            plugin(
                                    "org.apache.maven.plugins:maven-clean-plugin:" + MAVEN_CLEAN_PLUGIN_VERSION

    def "clean #gradleTask (Gradle vs Maven)"() {
        given:
        runner.testGroup = "Gradle vs Maven test build using Java plugin"
        configureMavenOptions(JavaTestProject.projectFor(runner.testProject))
        runner.gradleTasks = ["clean", gradleTask]
        runner.equivalentMavenTasks = ["clean", mavenTask]
        if (mavenTask == "package") {