stdout '.*mod[\\/]rsc.io[\\/]quote@v1.5.2$'

# downloaded dependencies are read-only
exists -readonly $GOPATH/pkg/mod/rsc.io/quote@v1.5.2
exists -readonly $GOPATH/pkg/mod/rsc.io/quote@v1.5.2/buggy

# go clean -modcache can delete read-only dependencies
go clean -modcache
! exists $GOPATH/pkg/mod/rsc.io/quote@v1.5.2

# list {{.Dir}} shows replaced directories
cp go.mod2 go.mod
go list -mod=mod -f {{.Dir}} rsc.io/quote

	} {
		if !panics(func() { _ = Delete(test.s, test.i, test.j) }) {
			t.Errorf("Delete %s: got no panic, want panic", test.name)
		}
	}
}

func TestDeleteClearTail(t *testing.T) {
	mem := []*int{new(int), new(int), new(int), new(int), new(int), new(int)}
	s := mem[0:5] // there is 1 element beyond len(s), within cap(s)

	s = Delete(s, 2, 4)

	if mem[3] != nil || mem[4] != nil {

			i := int64(0)
			copy := maps.Clone(m)
			for v := range s {
				if _, ok := copy[v.String()]; !ok {
					t.Fatalf("unexpected %v", v.Interface())
				}
				delete(copy, v.String())
				i++
			}
			if len(copy) != 0 {
				t.Fatalf("should loop four times")
			}
		}},
		{"chan int", ValueOf(c), func(t *testing.T, s iter.Seq[Value]) {
			i := 0

// README as a courtesy to explain where it came from.
const cacheREADME = `This directory holds cached build artifacts from the Go build system.
Run "go clean -cache" if the directory is getting too large.
Run "go clean -fuzzcache" to delete the fuzz cache.
See golang.org to learn more about Go.
`

// initDefaultCache does the work of finding the default cache
// the first time Default is called.
func initDefaultCache() {
	dir, _ := DefaultDir()

}

func delete1() {
	var m map[string]int
	var s string
	delete() // ERROR "not enough arguments"
	delete(1) // ERROR "not enough arguments"
	delete(1, 2, 3) // ERROR "too many arguments"
	delete(m, 0 /* ERROR "cannot use" */)
	delete(m, s)
	_ = delete /* ERROR "used as value" */ (m, s)

	var t []map[string]string
	delete(t... /* ERROR "invalid use of ..." */ )
}

func delete2() {

		g.inSyscall[ev.Proc()] = gs
	}
	// Check if we're exiting a non-blocking syscall.
	_, didNotBlock := g.inSyscall[ev.Proc()]
	if from == trace.GoSyscall && didNotBlock {
		gs.syscallEnd(ev.Time(), false, ctx)
		delete(g.inSyscall, ev.Proc())
	}

	// Note down the goroutine transition.
	_, inMarkAssist := gs.activeRanges["GC mark assist"]

		CoroCgo(callerStopCallback, iterNested)
	})
}

var toCall func()

//export go_callback_coro
func go_callback_coro(handle C.uintptr_t) {
	h := cgo.Handle(handle)
	h.Value().(func())()
	h.Delete()
}

func callFromC(f func()) {
	C.call_go(C.uintptr_t(cgo.NewHandle(f)))
}

func CoroCgo(driver func(iter.Seq[int]) error, seq iter.Seq[int]) {
	if err := driver(seq); err != nil {

}

func (c *clientCodec) ReadResponseHeader(r *rpc.Response) error {
	c.resp.reset()
	if err := c.dec.Decode(&c.resp); err != nil {
		return err
	}

	c.mutex.Lock()
	r.ServiceMethod = c.pending[c.resp.Id]
	delete(c.pending, c.resp.Id)
	c.mutex.Unlock()

	r.Error = ""
	r.Seq = c.resp.Id
	if c.resp.Error != nil || c.resp.Result == nil {
		x, ok := c.resp.Error.(string)
		if !ok {

			fname := m[1]
			delete(notInlinedReason, curPkg+"."+fname)
			continue
		}
		if m := canInline.FindStringSubmatch(line); m != nil {
			fname := m[1]
			fullname := curPkg + "." + fname
			// If function must be inlined somewhere, being inlinable is not enough
			if _, ok := must[fullname]; !ok {
				delete(notInlinedReason, fullname)
				continue
			}
		}

	defer handlers.Unlock()

	remove := func(n int) {
		var zerohandler handler

		for c, h := range handlers.m {
			if h.want(n) {
				handlers.ref[n]--
				h.clear(n)
				if h.mask == zerohandler.mask {
					delete(handlers.m, c)
				}
			}
		}

		action(n)
	}

	if len(sigs) == 0 {
		for n := 0; n < numSig; n++ {
			remove(n)
		}
	} else {
		for _, s := range sigs {
			remove(signum(s))
		}
	}