argValue = argType.getMethod("getValidPolicy", String.class).invoke(null, value);
        } catch (Exception e) {
            // New API not found. Fallback to legacy String argument.
            argType = String.class;
            argValue = value;
        }

        try {
            JavaMethod.of(TestNG.class, Object.class, "setConfigFailurePolicy", argType).invoke(testNg, argValue);
        } catch (NoSuchMethodException e) {

        fun Int.fooExt() {}

        val String.barExt: String
            get() = "bar"

        var Int.bazarExt: String
            get() = "bar"
            set(value) = Unit

        operator fun String.invoke(p: String, block: String.() -> Unit) = Unit

    """

    private
    val annotatedKotlinMembers = """

        /** @since 2.0 */
        @Incubating
        fun foo() {}

        /** @since 2.0 */

            }
            if (method.getName().equals("hashCode") && args == null) {
                return proxyHashCode(proxy);
            }
            return invoke(delegate.getClass(), delegate, boxedReturnType, method, args);
        }

        private <T, R> R invoke(Class<T> listenerType, Object listener, Class<R> returnType, Method method, Object[] args) {
            T listenerCast = listenerType.cast(listener);

        // Enable session tickets.
        setUseSessionTickets.invoke(sslSocket, true)

        // Assume platform support on 24+
        if (hostname != null && Build.VERSION.SDK_INT <= 23) {
          // This is SSLParameters.setServerNames() in API 24+.
          setHostname.invoke(sslSocket, hostname)
        }

        // Enable ALPN.
        setAlpnProtocols.invoke(
          sslSocket,

import org.gradle.internal.reflect.JavaPropertyReflectionUtil;
import org.gradle.internal.state.ModelObject;

import javax.annotation.Nullable;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Collections;

    ReflectionBasedServiceMethod(Method target) {
        super(target);
        javaMethod = JavaMethod.of(Object.class, target);
    }

    @Override
    public Object invoke(Object target, @Nullable Object... args) {
        try {
            return javaMethod.invoke(target, args);
        } catch (Exception e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    @Override

     *
     * @see [TaskContainer.named]
     */
    @Deprecated("Use named(String) instead.", ReplaceWith("named(this)"))
    operator fun String.invoke(): TaskProvider<Task> {
        DeprecationLogger.deprecateBehaviour(String.format("Task '%s' found by String.invoke() notation.", this))
            .withContext("The \"name\"() notation can cause confusion with methods provided by Kotlin or the JDK.")

        this.method = method;
        this.factory = factory;
    }

    @Override
    public R invoke(Object... args) {
        I instance = Modifier.isStatic(method.getModifiers()) ? null : factory.create();
        return method.invoke(instance, args);
    }

        }
    }

    @Override
    public java.lang.invoke.CallSite maybeDecorateIndyCallSite(java.lang.invoke.CallSite originalCallSite, MethodHandles.Lookup caller, String callType, String name, int flags) {
        CacheableCallSite ccs = toGroovyCacheableCallSite(originalCallSite);
        switch (callType) {
            case "invoke":

 * 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>