val application = ApplicationManager.getApplication()

        if (isProhibitedEdtAnalysis(application)) {
            return "Called in the EDT thread."
        }

        if (isProhibitedWriteActionAnalysis(application)) {
            return "Called from a write action."
        }

        permissionRegistry.explicitAnalysisRestriction?.let { restriction ->

		poll.TestHookDidSendFile = orig
	}()
	var (
		called     bool
		gotHandled bool
		gotFD      *poll.FD
	)
	poll.TestHookDidSendFile = func(dstFD *poll.FD, src int, written int64, err error, handled bool) {
		if called {
			t.Error("internal/poll.SendFile called multiple times, want one call")
		}
		called = true
		gotHandled = handled
		gotFD = dstFD
	}
	f()
	if !called {

	// function-valued expression, instead of being called.
	//
	// Per the spec:
	//  "The built-in functions do not have standard Go types, so they can only
	//  appear in call expressions; they cannot be used as function values."
	//
	// Example:
	//  var _ = copy
	UncalledBuiltin

	// InvalidAppend occurs when append is called with a first argument that is
	// not a slice.
	//

// run other goroutines.
//
// mcall can only be called from g stacks (not g0, not gsignal).
//
// This must NOT be go:noescape: if fn is a stack-allocated closure,
// fn puts g on a run queue, and g executes before fn returns, the
// closure will be invalidated while it is still executing.
func mcall(fn func(*g))

// systemstack runs fn on a system stack.
// If systemstack is called from the per-OS-thread (g0) stack, or

	ns.ObjectMeta.Labels = map[string]string{constants.DataplaneModeLabel: constants.DataplaneModeAmbient}

	testCmdAddExpectFail(t, cniConf, pod, ns)

	wasCalled := serverClose()
	// server called, but errored
	assert.Equal(t, wasCalled, true)
}

func TestCmdAddPodWithProxySidecarAmbientEnabledNS(t *testing.T) {
	url, serverClose := setupCNIEventClientWithMockServer(false)

        "top-level adder has a convention and is called"     | addToList("foo") | addToList("bar")   | "list = foo, bar"
        "top-level adder has a convention and is not called" | addToList("foo") | ""                 | "list = foo"
        "nested adder has a convention and is called"        | addToBaz("foo")  | addToBaz("bar")    | "baz = foo, bar"
        "nested adder has a convention and is not called"    | addToBaz("foo")  | ""                 | "baz = foo"

}

// HasSynced returns whether the underlying cache has synced and the callback has been called at least once.
func (c *crdWatcher) HasSynced() bool {
	return c.queue.HasSynced()
}

// Run starts the controller. This must be called.
func (c *crdWatcher) Run(stop <-chan struct{}) {
	c.mutex.Lock()
	if c.stop != nil {
		// Run already called. Because we call this from client.RunAndWait this isn't uncommon
		c.mutex.Unlock()

     *
     * This method should be called only once per build but multiple calls with the
     * same argument are allowed.
     *
     * @param settingsDir directory where to look for the {@code gradle.properties} file
     * @param setSystemProperties should system properties be set or not
     * @throws IllegalStateException if called with a different argument in the same build
     */

stderr 'invalid //go:debug: value contains space'

[short] skip

# Programs in Go 1.21 work module should trigger run-time error.
cp go.mod.21 go.mod
! go run .
stderr 'panic: panic called with nil argument'

! go run rsc.io/panicnil
stderr 'panic: panic called with nil argument'

# Programs in Go 1.20 work module use old panic nil behavior.
cp go.mod.20 go.mod
! go run .
stderr 'panic: nil'

! go run rsc.io/panicnil

     * superconfigurations.
     */
    Set<ExcludeRule> getAllExcludeRules();

    /**
     * @implSpec Usage: This method should only be called on resolvable configurations and should throw an exception if
     * called on a configuration that does not permit this usage.
     */
    @Nullable
    ConfigurationInternal getConsistentResolutionSource();

    /**