[!fuzz] skip
[!cgo] skip
[short] skip
env GOCACHE=$WORK/cache

# Test that fuzzing works with cgo (issue 65169)

go test -fuzz=. -fuzztime=1x
stdout ok
! stdout FAIL

-- go.mod --
module example.com/p

go 1.20
-- c.go --
package p

import "C"
-- c_test.go --
package p

import "testing"

func Fuzz(f *testing.F) {
	f.Add(0)
	f.Fuzz(func(t *testing.T, x int) {})

`hello` `world`.
-->

<style>
  main ul li { margin: 0.5em 0; }
</style>

## DRAFT RELEASE NOTES — Introduction to Go 1.23 {#introduction}

**Go 1.23 is not yet released. These are work-in-progress release notes.

        override val scheduledWork: ScheduledWork
            get() {
                lateinit var work: ScheduledWork
                gradle.taskGraph.visitScheduledNodes { nodes, entryNodes -> work = ScheduledWork(nodes, entryNodes) }
                return work
            }
    }

    private
    inner class DefaultConfigurationCacheBuild(
        override val state: BuildState,

// fmtCmd formats a command in the manner of fmt.Sprintf but also:
//
//	fmtCmd replaces the value of b.WorkDir with $WORK.
func (sh *Shell) fmtCmd(dir string, format string, args ...any) string {
	cmd := fmt.Sprintf(format, args...)
	if sh.workDir != "" && !strings.HasPrefix(cmd, "cat ") {
		cmd = strings.ReplaceAll(cmd, sh.workDir, "$WORK")
		escaped := strconv.Quote(sh.workDir)
		escaped = escaped[1 : len(escaped)-1] // strip quote characters

        expect:
        2.times {
            run("work", "--parallel")
            result.assertTaskOrder(":a:work", ":a:finalizer", ":b:work")
        }

        and: "Apply workaround"
        buildFile """
            configure(project(':b')) {
                work.mustRunAfter(":a:work")
            }
        """
        2.times {
            run("work", "--parallel")

        events.contains([profile: "project fingerprint", type: "C", "frame": ProjectFingerprint.name])

        and: "Gradle and Work Graph events are logged"
        events.contains([profile: "build ':' state", type: "O", frame: "Gradle"])
        events.contains([profile: "build ':' state", type: "O", frame: "Work Graph"])

        and: "state frame events are logged"
        events.contains([profile: "build ':' state", type: "O", frame: ":ok"])

	CmdClean.Flag.BoolVar(&cleanTestcache, "testcache", false, "")

	// -n and -x are important enough to be
	// mentioned explicitly in the docs but they
	// are part of the build flags.

	work.AddBuildFlags(CmdClean, work.DefaultBuildFlags)
}

func runClean(ctx context.Context, cmd *base.Command, args []string) {
	if len(args) > 0 {
		cacheFlag := ""
		switch {
		case cleanCache:
			cacheFlag = "-cache"

	return nil
}

func TestDeadlineWorker(t *testing.T) {
	work := NewDeadlineWorker(500 * time.Millisecond)

	err := work.Run(func() error {
		time.Sleep(600 * time.Millisecond)
		return nil
	})
	if err != context.DeadlineExceeded {
		t.Error("DeadlineWorker shouldn't be successful - should return context.DeadlineExceeded")
	}

	err = work.Run(func() error {
		time.Sleep(450 * time.Millisecond)
		return nil
	})

		case "GODEBUG":
			env[i].Changed = env[i].Value != ""
		}
	}

	if work.GccgoBin != "" {
		env = append(env, cfg.EnvVar{Name: "GCCGO", Value: work.GccgoBin, Changed: true})
	} else {
		env = append(env, cfg.EnvVar{Name: "GCCGO", Value: work.GccgoName})
	}

	goarch, val, changed := cfg.GetArchEnv()
	if goarch != "" {

        when: 'repo is not disabled'
        repositoryBlacklister.isDisabled(REPOSITORY_ID) >> false
        access.listModuleVersions(dependency, result)

        then: 'work is delegated'
        1 * delegate.listModuleVersions(dependency, result)

        when: 'exception is thrown in resolution'
        repositoryBlacklister.getDisabledReason(REPOSITORY_ID) >> Optional.of(exception)