! stdout ^ok
stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithNoCache[/\\]'
stdout FAIL

# Write a crashing input to the cache
mkdir $GOCACHE/fuzz/example.com/x/FuzzWithCache
cp cache-file $GOCACHE/fuzz/example.com/x/FuzzWithCache/1

# Test that fuzzing a target with a failure in the cache prints the crash
# and writes this as a "new" crash to testdata/fuzz

# the last minimization step should not increase the coverage.

[short] skip
[!fuzz-instrumented] skip

env GOCACHE=$WORK/gocache
go test -fuzz=FuzzCovMin -fuzztime=500000x -test.fuzzcachedir=$GOCACHE/fuzz
go run check_file/main.go $GOCACHE/fuzz/FuzzCovMin ab

-- go.mod --
module test

-- covmin_test.go --
package covmin

import "testing"

func FuzzCovMin(f *testing.F) {

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"./dcache"
)

func main() {
	var m dcache.Module
	m.Configure("x")
	m.Configure("y")
	var e error
	m.Blurb("x", e)

import org.junit.jupiter.api.Test

class CacheControlJvmTest {
  @Test
  @Throws(Exception::class)
  fun completeBuilder() {
    val cacheControl =
      CacheControl.Builder()
        .noCache()
        .noStore()
        .maxAge(1, TimeUnit.SECONDS)
        .maxStale(2, TimeUnit.SECONDS)
        .minFresh(3, TimeUnit.SECONDS)
        .onlyIfCached()
        .noTransform()
        .immutable()

# functions called by testing or internal/fuzz in the background.

go test -c -fuzz=.  # Build using shared build cache for speed.
env GOCACHE=$WORK/gocache
exec ./fuzz.test$GOEXE -test.fuzzcachedir=$GOCACHE/fuzz -test.fuzz=FuzzMinCache -test.fuzztime=1000x
go run check_cache/check_cache.go $GOCACHE/fuzz/FuzzMinCache

# Test that minimization occurs for a crash that appears while minimizing a

# Test go build -pgo=auto flag.

[short] skip 'compiles and links executables'

# Set up fresh GOCACHE.
env GOCACHE=$WORK/gocache
mkdir $GOCACHE

# use default.pgo for a single main package
go build -n -pgo=auto -o a1.exe ./a/a1
stderr 'preprofile.*-i.*default\.pgo'
stderr 'compile.*-pgoprofile=.*a1.go'

# check that pgo applied to dependencies
stderr 'compile.*-p test/dep.*-pgoprofile=.*'

# check that pgo appears in build info

class CacheControlTest {
  @Test
  @Throws(Exception::class)
  fun emptyBuilderIsEmpty() {
    val cacheControl = CacheControl.Builder().build()
    assertThat(cacheControl.toString()).isEqualTo("")
    assertThat(cacheControl.noCache).isFalse()
    assertThat(cacheControl.noStore).isFalse()
    assertThat(cacheControl.maxAgeSeconds).isEqualTo(-1)
    assertThat(cacheControl.sMaxAgeSeconds).isEqualTo(-1)
    assertThat(cacheControl.isPrivate).isFalse()

# Test that the user can override default code generation flags.

[compiler:gccgo] skip  # gccgo does not use -gcflags
[!cgo] skip
[!GOOS:linux] skip  # test only works if c-archive implies -shared
[short] skip

env GOCACHE=$WORK/gocache  # Looking for compile commands, so need a clean cache.
go build -x -n -buildmode=c-archive -gcflags=all=-shared=false ./override.go
stderr '^.*/compile (.* )?-shared (.* )?-shared=false'

-- override.go --

    -e IN_BUILD_CONTAINER=1 \
    -e TZ="${TIMEZONE:-$TZ}" \
    --mount "type=bind,source=${MOUNT_SOURCE},destination=/work" \
    --mount "type=volume,source=go,destination=/go" \
    --mount "type=volume,source=gocache,destination=/gocache" \
    --mount "type=volume,source=cache,destination=/home/.cache" \
    --mount "type=volume,source=crates,destination=/home/.cargo/registry" \
    --mount "type=volume,source=git-crates,destination=/home/.cargo/git" \

# Normally, the default is gcc or clang, but if CC was set during make.bash,
# that becomes the default.
[!cc:clang] [!cc:gcc] skip 'C compiler is not gcc or clang'

env GOCACHE=$WORK/gocache  # Looking for compile flags, so need a clean cache.
[!GOOS:windows] env PATH=.:$PATH
[!GOOS:windows] chmod 0755 p/gcc p/clang
[!GOOS:windows] exists -exec p/gcc p/clang
[GOOS:windows] exists -exec p/gcc.bat p/clang.bat