fun `can create and configure tasks`() {

        val clean = mock<Delete>()
        val cleanProvider = mockTaskProviderFor(clean)

        val tasks = mock<TaskContainer> {
            on { create(eq("clean"), eq(Delete::class.java), any<Action<Delete>>()) } doReturn clean
            on { getByName("clean") } doReturn clean
            onNamedWithAction("clean", Delete::class, cleanProvider)
        }

        tasks {

	{"abc/../../././../def", "../../def"},
}

func TestClean(t *testing.T) {
	for _, test := range cleantests {
		if s := Clean(test.path); s != test.result {
			t.Errorf("Clean(%q) = %q, want %q", test.path, s, test.result)
		}
		if s := Clean(test.result); s != test.result {
			t.Errorf("Clean(%q) = %q, want %q", test.result, s, test.result)
		}
	}
}

func TestCleanMallocs(t *testing.T) {
	if testing.Short() {

env GO111MODULE=off
[short] skip

# go clean -testcache
# should work (see golang.org/issue/29757).
cd x
go test x_test.go
go clean -testcache
go test x_test.go
! stdout 'cached'
! go clean -testcache ../x
stderr 'go: clean -testcache cannot be used with package arguments'

# golang.org/issue/29100: 'go clean -testcache' should succeed
# if the cache directory doesn't exist at all.

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

                        )
                    )
                )
            )
        )
    }

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

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

        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(

			a, err := txtar.ParseFile(file)
			if err != nil {
				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,

                '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:

type RawSockaddrDatalink struct {
	Len    uint8
	Family uint8
	Index  uint16
	Type   uint8
	Nlen   uint8
	Alen   uint8
	Slen   uint8
	Data   [12]int8
}

type RawSockaddr struct {
	Len    uint8
	Family uint8
	Data   [14]int8
}

type RawSockaddrAny struct {
	Addr RawSockaddr
	Pad  [92]int8
}

type _Socklen uint32

type Linger struct {
	Onoff  int32
	Linger int32
}

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