func (c *FakeCustomResourceDefinitions) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.CustomResourceDefinition, err error) {
	emptyResult := &v1.CustomResourceDefinition{}
	obj, err := c.Fake.
		Invokes(testing.NewRootGetAction(customresourcedefinitionsResource, name), emptyResult)
	if obj == nil {
		return emptyResult, err
	}
	return obj.(*v1.CustomResourceDefinition), err
}

func (c *FakeCustomResourceDefinitions) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1beta1.CustomResourceDefinition, err error) {
	emptyResult := &v1beta1.CustomResourceDefinition{}
	obj, err := c.Fake.
		Invokes(testing.NewRootGetAction(customresourcedefinitionsResource, name), emptyResult)
	if obj == nil {
		return emptyResult, err
	}
	return obj.(*v1beta1.CustomResourceDefinition), err
}

	_, err := c.Fake.Invokes(action, &v1.ExampleList{})
	return err
}

// Patch applies the patch and returns the patched example.
func (c *FakeExamples) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.Example, err error) {
	emptyResult := &v1.Example{}
	obj, err := c.Fake.

//
// If an exit hook panics, Run will throw with the panic on the stack.
// If an exit hook invokes exit in the same goroutine, the goroutine will throw.
// If an exit hook invokes exit in another goroutine, that exit will block.
func Run(code int) {
	for !locked.CompareAndSwap(0, 1) {
		if Goid() == runGoid.Load() {
			Throw("exit hook invoked exit")
		}
		Gosched()
	}
	defer locked.Store(0)
	runGoid.Store(Goid())

	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.

	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")
	}

import org.gradle.internal.installation.CurrentGradleInstallation;

import java.lang.reflect.Method;

public class ProcessBootstrap {
    /**
     * Sets up the ClassLoader structure for the given class, creates an instance and invokes {@link EntryPoint#run(String[])} on it.
     */
    public static void run(String mainClassName, String[] args) {
        try {
            runNoExit(mainClassName, args);
            System.exit(0);

}

# run invokes apidiff once per target and stores the output
# file(s) in the given directory.
run () {
    out="$1"
    mkdir -p "$out"
    for d in "${targets[@]}"; do
        apidiff -m -w "${out}/$(output_name "${d}")" "${d}"
    done
}

# runWorktree checks out a specific revision, then invokes run there.
runWorktree () {
    local out="$1"

     */
    boolean isSingleUse();

    /**
     * Invokes the given action when the Daemon becomes unhealthy in way that requires it be terminated at the end of the build.
     * <p>
     * The action will be invoked at-most once during a build.
     * It will only be invoked for the build in which it was registered (i.e. not subsequent builds).

 * limitations under the License.
 */

package org.gradle.internal.classpath.intercept;

import org.codehaus.groovy.runtime.callsite.CallSite;

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.util.Set;

/**
 * Intercepts method and constructor calls as well as property reads in dynamic Groovy bytecode.
 * <p>