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
}

            args '--parallel', '--max-workers=2'
            succeeds(generate.path, clean.path)

            result.assertTaskOrder(generateFoo.fullPath, generateBar.fullPath, generate.fullPath)
            result.assertTaskOrder(generateFoo.fullPath, cleanFoo.fullPath, clean.fullPath)
            result.assertTaskOrder(generateBar.fullPath, cleanBar.fullPath, clean.fullPath)
        }

        where:
        type << ProductionType.values()

        expect:
        2.times {
            args '--parallel', '--max-workers=2'
            succeeds(clean.path, generate.path)

            result.assertTaskOrder(cleanBar.fullPath, clean.fullPath)
            result.assertTaskOrder(generateFoo.fullPath, cleanFoo.fullPath, clean.fullPath)
            result.assertTaskOrder(generateFoo.fullPath, generate.fullPath)

env GOCACHE=$WORK/cache

# Build something so that the cache gets populates
go build main.go

# Check that cache contains directories before running
exists $GOCACHE/00

# Run go clean -cache -n and ensure that directories weren't deleted
go clean -cache -n
exists $GOCACHE/00

# Re-run go clean cache without the -n flag go ensure that directories were properly removed
go clean -cache

# 'go clean -r -modcache' should clean only the dependencies that are within the
# main module.
# BUG(golang.org/issue/28680): Today, it cleans across module boundaries.
cd r
exists ./test.out
exists ../replaced/test.out
go clean -r -modcache
! exists ./test.out
! exists ../replaced/test.out  # BUG: should still exist

# 'go clean -modcache' should not download anything before cleaning.

    }

    def "clean build and build clean work reliably with composite build"() {
        given:
        dependency "org.test:buildB:1.0"
        buildA.buildFile << """
            clean {
                dependsOn gradle.includedBuild('buildB').task(':clean')
            }
        """

        when:
        args "--parallel"
        execute(buildA, "clean", "build")

        then:

[short] skip

# --------------------- clean executables -------------------------

# case1: test file-named executable 'main'
env GO111MODULE=on

! exists main$GOEXE
go build main.go
exists -exec main$GOEXE
go clean
! exists main$GOEXE

# case2: test module-named executable 'a.b.c'
! exists a.b.c$GOEXE
go build
exists -exec a.b.c$GOEXE
go clean
! exists a.b.c$GOEXE

public class CleanRule implements Rule {

    public static final String CLEAN = "clean";

    private final TaskContainer tasks;

    public CleanRule(TaskContainer tasks) {
        this.tasks = tasks;
    }

    @Override
    public String getDescription() {
        return "Pattern: " + CLEAN + "<TaskName>: Cleans the output files of a task.";
    }

    @Override

go test -fuzz=FuzzY -fuzztime=100x .
go run ./contains_files $GOCACHE/fuzz/example.com/y/FuzzY

# 'go clean -cache' should not delete the fuzz cache.
go clean -cache
exists $GOCACHE/fuzz

# 'go clean -fuzzcache' should delete the fuzz cache but not the build cache.
go build -x ./empty
stderr '(compile|gccgo)( |\.exe).*empty.go'
go clean -fuzzcache
! exists $GOCACHE/fuzz
go build -x ./empty
! stderr '(compile|gccgo)( |\.exe).*empty.go'

    }

    // <lifecycle>
    //   <id>clean</id>
    //   <phases>
    //     <phase>pre-clean</phase>
    //     <phase>clean</phase>
    //     <phase>post-clean</phase>
    //   </phases>
    //   <default-phases>
    //     <clean>org.apache.maven.plugins:maven-clean-plugin:clean</clean>
    //   </default-phases>
    // </lifecycle>

    private String id;