// care".
	nlen, alen, slen := int(b[1]), int(b[2]), int(b[3])
	if nlen == 0xff {
		nlen = 0
	}
	if alen == 0xff {
		alen = 0
	}
	if slen == 0xff {
		slen = 0
	}
	l := 4 + nlen + alen + slen
	if len(b) < l {
		return 0, nil, errInvalidAddr
	}
	data := b[4:]
	var name string
	var addr []byte
	if nlen > 0 {
		name = string(data[:nlen])

		log.Fatal(err)
	}

	defer os.RemoveAll(dir) // clean up

	tmpfn := filepath.Join(dir, "tmpfile")
	if err := ioutil.WriteFile(tmpfn, content, 0666); err != nil {
		log.Fatal(err)
	}
}

func ExampleTempDir_suffix() {
	parentDir := os.TempDir()
	logsDir, err := ioutil.TempDir(parentDir, "*-logs")
	if err != nil {
		log.Fatal(err)
	}
	defer os.RemoveAll(logsDir) // clean up

        def snapshot = reportFile.snapshot()
        then:
        executedAndNotSkipped ":test", ":jacocoTestReport", ":jacocoTestCoverageVerification"
        reportFile.assertIsFile()

        when:
        succeeds "clean"
        then:
        reportFile.assertDoesNotExist()

        when:
        withBuildCache().run "jacocoTestReport", "jacocoTestCoverageVerification"
        then:

	"unsafe"
)

// The compiler emits calls to runtime.addCovMeta
// but this code has moved to rtcov.AddMeta.
func addCovMeta(p unsafe.Pointer, dlen uint32, hash [16]byte, pkgpath string, pkgid int, cmode uint8, cgran uint8) uint32 {
	id := rtcov.AddMeta(p, dlen, hash, pkgpath, pkgid, cmode, cgran)
	if id == 0 {
		throw("runtime.addCovMeta: coverage package map collision")
	}
	return id

        withBuildCache().run 'clean', cacheableTask

        then:
        executedAndNotSkipped(cacheableTask)
        cacheOperations.assertStoredToLocalCacheForTask(cacheableTask)
        cacheOperations.assertNotStoredToRemoteCacheForTask(cacheableTask)

        when:
        pullOnly()
        cacheOriginInputFile.text = 'remote'
        withBuildCache().run 'clean', cacheableTask

        then:

[exec:echo] go bug

# commands that load the package in the current directory fail
! go build
! go fmt
! go generate
! go get
! go install
! go list
! go run
! go test
! go vet

# clean succeeds, even with -modcache
go clean -modcache

# doc succeeds for standard library
go doc unsafe

# env succeeds
go env

# tool succeeds
go tool -n test2json

# version succeeds
go version

-- x.mod --

        def firstBuildId = buildInvocationId
        def firstBuildCacheKey = buildCacheKey(":write")
        originBuildInvocationId(":write") == null

        when:
        succeeds "clean", "write"

        then:
        skipped ":write"
        def secondBuildId = buildInvocationId
        firstBuildId != secondBuildId
        with(origin(":write")) {
            buildInvocationId == firstBuildId

            invocation {
                cleanTasks("clean")
                args("--build-cache")
            }
            warmUpCount = 2
            invocationCount = 4
        }
        runner.baseline {
            displayName("fully up-to-date")
        }
        runner.baseline {
            displayName("non-cached")
            invocation {
                cleanTasks('clean')
            }
            warmUpCount = 2

    }

    def "creates tasks and applies mappings"() {
        when:
        project.pluginManager.apply(BasePlugin)

        then:
        def clean = project.tasks[BasePlugin.CLEAN_TASK_NAME]
        clean instanceOf(Delete)
        clean dependsOn()
        clean.targetFiles.files == [project.buildDir] as Set

        and:
        def assemble = project.tasks[BasePlugin.ASSEMBLE_TASK_NAME]

def classesDir = file('build/classes')
classesDir.mkdirs()
tasks.register('clean', Delete) {
    delete 'build'
}
tasks.register('compile') {
    dependsOn 'clean'
    def localClassesDir = classesDir
    doLast {
        if (!localClassesDir.isDirectory()) {
            println 'The class directory does not exist. I can not operate'
            // do something
        }
        // do something
    }