stdout '^flag \[fmt\.test\] MAP: map\[fmt:fmt \[fmt\.test\]\]'
stdout '^fmt\.test MAP: map\[(.* )?testing:testing \[fmt\.test\]'
! stdout '^fmt\.test MAP: map\[(.* )?os:'
stdout '^fmt\.test IMPORT: \[fmt \[fmt\.test\] fmt_test \[fmt\.test\] os reflect testing \[fmt\.test\] testing/internal/testdeps \[fmt\.test\]\]'


-- a/b/b.go --
package b

import _ "c/d"
-- a/vendor/c/d/d.go --

The [Map.Clear] method deletes all the entries, resulting in

# is unable to actually minimize the input. We do this by checking that
# an expected value appears in the cache. If a dirty coverage map is used
# (i.e. the coverage map generated during the last minimization step,
# rather than the map provided with the initial input) then this value
# is unlikely to appear in the cache, since the map generated during
# the last minimization step should not increase the coverage.

[short] skip
[!fuzz-instrumented] skip

// parser after missing type. There should be exactly
// one error each time, with now follow errors.

package p

func g() {
	m := make(map[string]! /* ERROR "expected type, found '!'" */ )
	for {
		x := 1
		print(x)
	}
}

func f() {
	m := make(map[string]) /* ERROR "expected type, found '\)'" */
	for {
		x := 1
		print(x)
	}

pkg maps, func All[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq2[$1, $2] #61900
pkg maps, func Collect[$0 comparable, $1 interface{}](iter.Seq2[$0, $1]) map[$0]$1 #61900
pkg maps, func Insert[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0, iter.Seq2[$1, $2]) #61900
pkg maps, func Keys[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq[$1] #61900

# and -fno-canonical-systemd-headers are permitted for internal linking.
env CGO_CFLAGS=-fdebug-prefix-map=old=/tmp/new
go build -x -n -o dummy.exe ./usesInternalCgo
! stderr preferlinkext
env CGO_CFLAGS=-ffile-prefix-map=/Users/someone/_11233/things=new
go build -x -n -o dummy.exe ./usesInternalCgo
! stderr preferlinkext
env CGO_CFLAGS=-no-canonical-prefixes

- [Values](/pkg/maps#Values) returns an iterator over values in m.
- [Insert](/pkg/maps#Insert) adds the key-value pairs from seq to m.

go list -f 'ImportPath: "{{.ImportPath}}", Imports: "{{.Imports}}", ImportMap: "{{.ImportMap}}"' m/a m/b
cmp stdout want

-- want --
ImportPath: "m/a", Imports: "[m/b [m/a]]", ImportMap: "map[m/b:m/b [m/a]]"
ImportPath: "m/b", Imports: "[m/c]", ImportMap: "map[]"
-- go.mod --
module m

go 1.23

-- a/a.go --
package main

import _ "m/b"
-- a/default.pgo --
-- b/b.go --
package a

import _ "m/c"

[GOOS:illumos] skip "skipping on Solaris; see golang.org/issue/13247"

go build -o $WORK/exe1$GOEXE cgotest
go build -x -o $WORK/exe2$GOEXE cgotest

# TODO(matloob): skip if stderr does not contain '-fdebug-prefix-map=\$WORK'

cmp $WORK/exe1$GOEXE $WORK/exe2$GOEXE

-- go.mod --
module cgotest

go 1.16
-- m.go --
package cgotest

import "C"

// (ie. more mutations, and compiler instrumentation)
func FuzzMutator(f *testing.F) {
	// TODO(katiehockman): simplify this once we can dedupe crashes (e.g.
	// replace map with calls to panic, and simply count the number of crashes
	// that were added to testdata)
	crashes := make(map[string]bool)
	// No seed corpus initiated
	f.Fuzz(func(t *testing.T, b []byte) {
		crashes[string(b)] = true
		if len(crashes) >= 10 {