defer func() {
		recover()
	}()
	x = px.(Exported)
	
	println("should not get this far")

	// this is a legitimate call, but because of the previous assignment,
	// it invokes the method private in p!
	x.private()  // p.Implementation.private()

    def obj = new MixInClosurePropertiesAsMethodsDynamicObject() {
        @Override
        String getDisplayName() {
            return "<obj>"
        }
    }

    def "invokes method on first delegate that has a property with closure value"() {
        def obj1 = Mock(DynamicObject)
        def obj2 = Mock(DynamicObject)
        def obj3 = Mock(DynamicObject)
        obj.setObjects(obj1, obj2, obj3)

//go:build !wasm && !windows

package ld

import (
	"os"
	"os/exec"
	"path/filepath"
	"syscall"
)

const syscallExecSupported = true

// execArchive invokes the archiver tool with syscall.Exec(), with
// the expectation that this is the last thing that takes place
// in the linking operation.
func (ctxt *Link) execArchive(argv []string) {
	var err error
	argv0 := argv[0]

	return false
}

// RawControl invokes the user-defined function f for a non-IO
// operation.
func (fd *FD) RawControl(f func(uintptr)) error {
	return errors.New("not implemented")
}

// RawRead invokes the user-defined function f for a read operation.
func (fd *FD) RawRead(f func(uintptr) bool) error {
	return errors.New("not implemented")
}

// RawWrite invokes the user-defined function f for a write operation.

import org.gradle.internal.concurrent.Stoppable;

import java.util.function.BiConsumer;
import java.util.function.Consumer;

public interface BuildWorkPlan extends Stoppable {
    /**
     * Invokes the given action when a task completes (as per {@link Node#isComplete()}). Does nothing for tasks that have already completed.
     */
    void onComplete(Consumer<LocalTaskNode> handler);

    void addFilter(Spec<Task> filter);

	if mode == "" {
		return
	}
	cover2.mode = mode
	cover2.tearDown = tearDown
	cover2.snapshotcov = snapcov
}

// coverReport2 invokes a callback in _testmain.go that will
// emit coverage data at the point where test execution is complete,
// for "go test -cover" runs.
func coverReport2() {
	if !goexperiment.CoverageRedesign {
		panic("unexpected")
	}

# Test that we can use the external linker with a host syso file that is
# embedded in a package, that is referenced by a Go assembly function.
# See issue 33139.

[!compiler:gc] skip
[!cgo] skip
[short] skip 'invokes system C compiler'

# External linking is not supported on linux/ppc64.
# See: https://github.com/golang/go/issues/8912
[GOOS:linux] [GOARCH:ppc64] skip

cc -c -o syso/objTestImpl.syso syso/src/objTestImpl.c

/**
 * Creates instance of objects in preparation for deserialization of their state.
 */
public interface DeserializationInstantiator {
    /**
     * Creates an instance of the given type without invoking its constructor. Invokes the constructor of the given base class.
     *
     * @throws ObjectInstantiationException On failure to create the new instance.
     */

	WaitForConfig(defaultNamespace string, configs string) error

	// Invoke invokes an istioctl command and returns the output and exception.
	// stdout and stderr will be returned as different strings
	Invoke(args []string) (string, string, error)

	// InvokeOrFail calls Invoke and fails tests if it returns en err
	InvokeOrFail(t test.Failer, args []string) (string, string)
}

  /// `callable_options`.
  /// NOTE: This API is still experimental and may change.
  Status MakeCallable(const CallableOptions& callable_options,
                      CallableHandle* out_handle);

  /// \brief Invokes the subgraph named by `handle` with the given options and
  /// input tensors.
  ///
  /// The order of tensors in `feed_tensors` must match the order of names in