type RawSockaddrDatalink struct {
	Len    uint8
	Family uint8
	Index  uint16
	Type   uint8
	Nlen   uint8
	Alen   uint8
	Slen   uint8
	Data   [24]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
}

	}
	perr, ok := err.(*PathError)
	if !ok {
		t.Fatalf("MkdirAll %q returned %T, not *PathError", fpath, err)
	}
	if filepath.Clean(perr.Path) != filepath.Clean(fpath) {
		t.Fatalf("MkdirAll %q returned wrong error path: %q not %q", fpath, filepath.Clean(perr.Path), filepath.Clean(fpath))
	}

	// Can't make subdirectory of file.
	ffpath := fpath + "/subdir"
	err = MkdirAll(ffpath, 0777)
	if err == nil {

     * cache. This scenario measures how much overhead Gradle's startup and input fingerprinting add on top of the cache hits.
     */
    def "clean check on ephemeral ci with remote http cache"() {
        runner.cleanTasks = ["clean"]
        runner.tasksToRun = ["check"]
        protocol = "http"
        pushToRemote = true
        runner.useDaemon = false
        runner.warmUpRuns = 1

    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 {

        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"
    }

    def "cacheable task with cache disabled doesn't get cached"() {

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.

  "durations" : [ {
    "testProject" : "largeAndroidBuild",
    "linux" : 492
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.android.RealLifeAndroidBuildPerformanceTest.clean assembleDebug with clean transforms cache",
  "durations" : [ {
    "testProject" : "largeAndroidBuild",
    "linux" : 1620
  }, {
    "testProject" : "nowInAndroidBuild",
    "linux" : 3580
  }, {

                        )
                    )
                )
            )
        )
    }

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

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

        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"
    }

        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(