}

func (f *FakeRuntime) AssertKilledContainers(containers []string) bool {
	f.Lock()
	defer f.Unlock()
	return f.assertList(containers, f.KilledContainers)
}

func (f *FakeRuntime) Type() string {
	return f.RuntimeType
}

func (f *FakeRuntime) Version(_ context.Context) (kubecontainer.Version, error) {
	f.Lock()
	defer f.Unlock()

	Value   interface{}
}

func (f *fakeResourceManager) Expect() ResourceManager {
	return &f.expect
}

func (f *fakeResourceManager) HasExpectedNumberActions() bool {
	f.lock.RLock()
	defer f.lock.RUnlock()

	f.expect.lock.RLock()
	defer f.expect.lock.RUnlock()

	return len(f.Actions) >= len(f.expect.Actions)
}

func (f *fakeResourceManager) Validate() error {
	f.lock.RLock()
	defer f.lock.RUnlock()

	b = f(a, b)
	b = f(b, a)

	// Defined directed channels win over defined bidirectional channels.
	A = f(A, a)
	A = f(a, A)
	B = f(B, b)
	B = f(b, B)

	f(a, b, B)
	f(a, B, b)
	f(b, B, a)
	f(b, a, B)
	f(B, a, b)
	f(B, b, a)

	// Differently named channel types conflict irrespective of channel direction.
	f(A, B /* ERROR "type namedB of B does not match inferred type namedA for T" */)

		if f.zero {
			memclrNoHeapPointers(v, f.size)
		}
		return v
	}
	if uintptr(f.nchunk) < f.size {
		f.chunk = uintptr(persistentalloc(uintptr(f.nalloc), 0, f.stat))
		f.nchunk = f.nalloc
	}

	v := unsafe.Pointer(f.chunk)
	if f.first != nil {
		f.first(f.arg, v)
	}
	f.chunk = f.chunk + f.size
	f.nchunk -= uint32(f.size)
	f.inuse += f.size
	return v
}

func (f *fixalloc) free(p unsafe.Pointer) {

	defer f.Unlock()
	f.Stopped = false
	f.result = make(chan Event, DefaultChanSize)
}

func (f *RaceFreeFakeWatcher) ResultChan() <-chan Event {
	f.Lock()
	defer f.Unlock()
	return f.result
}

// Add sends an add event.
func (f *RaceFreeFakeWatcher) Add(obj runtime.Object) {
	f.Lock()
	defer f.Unlock()
	if !f.Stopped {
		select {
		case f.result <- Event{Added, obj}:
			return
		default:

		"var a T[int]; type T[P any] struct{}; func (*T[P]) f() {}":  {},
		"var a *T[int]; type T[P any] struct{}; func (*T[P]) f() {}": {{"f", []int{0}, true}},

		// Interfaces
		"var a T; type T interface{ f() }":                           {{"f", []int{0}, true}},
		"var a T1; type ( T1 T2; T2 interface{ f() } )":              {{"f", []int{0}, true}},

		// add file and verify name and size
		f := fset.AddFile(test.filename, fset.Base()+delta, test.size)
		if f.Name() != test.filename {
			t.Errorf("got filename %q; want %q", f.Name(), test.filename)
		}
		if f.Size() != test.size {
			t.Errorf("%s: got file size %d; want %d", f.Name(), f.Size(), test.size)
		}
		if fset.File(f.Pos(0)) != f {
			t.Errorf("%s: f.Pos(0) was not found in f", f.Name())
		}

func (f exprFlags) Assignable() bool      { return f&64 != 0 }
func (f exprFlags) HasOk() bool           { return f&128 != 0 }
func (f exprFlags) IsRuntimeHelper() bool { return f&256 != 0 } // a runtime function called from transformed syntax

func (f *exprFlags) SetIsVoid()          { *f |= 1 }
func (f *exprFlags) SetIsType()          { *f |= 2 }
func (f *exprFlags) SetIsBuiltin()       { *f |= 4 }

)

func FuzzSplitPkgConfigOutput(f *testing.F) {
	testenv.MustHaveExecPath(f, "/bin/sh")

	f.Add([]byte(`$FOO`))
	f.Add([]byte(`\$FOO`))
	f.Add([]byte(`${FOO}`))
	f.Add([]byte(`\${FOO}`))
	f.Add([]byte(`$(/bin/false)`))
	f.Add([]byte(`\$(/bin/false)`))
	f.Add([]byte(`$((0))`))
	f.Add([]byte(`\$((0))`))
	f.Add([]byte(`unescaped space`))
	f.Add([]byte(`escaped\ space`))
	f.Add([]byte(`"unterminated quote`))

		f.walk(n.Body, ctxTypeSwitch, visit)
	case *ast.CommClause:
		f.walk(n.Comm, ctxStmt, visit)
		f.walk(n.Body, ctxStmt, visit)
	case *ast.SelectStmt:
		f.walk(n.Body, ctxStmt, visit)
	case *ast.ForStmt:
		f.walk(n.Init, ctxStmt, visit)
		f.walk(&n.Cond, ctxExpr, visit)
		f.walk(n.Post, ctxStmt, visit)
		f.walk(n.Body, ctxStmt, visit)
	case *ast.RangeStmt:
		f.walk(&n.Key, ctxExpr, visit)