// 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;

            Method getBuildListeners = projectClass.getDeclaredMethod("getBuildListeners");
            Vector listeners = (Vector) getBuildListeners.invoke(project);
            removeBuildListener.invoke(project, listeners.get(0));
            addBuildListener.invoke(project, antLogger);
        } catch (Exception ex) {
            throw UncheckedException.throwAsUncheckedException(ex);
        }
    }

        systemctl daemon-reload
        systemctl restart fess.service || true

    elif [ -x /etc/init.d/fess ]; then
        if command -v invoke-rc.d >/dev/null; then
            invoke-rc.d fess stop || true
            invoke-rc.d fess start || true
        else
            /etc/init.d/fess restart || true
        fi

    # older suse linux distributions do not ship with systemd

    Class<?> test = classLoader.loadClass(FuturesTest.class.getName());
    Object testInstance = test.getDeclaredConstructor().newInstance();
    test.getMethod("setUp").invoke(testInstance);
    test.getMethod(getName()).invoke(testInstance);
    test.getMethod("tearDown").invoke(testInstance);
  }

  private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)
      throws Exception {

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

	{"text", "some text", "some text", nil, true},
	{"invoke x", `{{template "x" .SI}}`, "TEXT", tVal, true},
	{"invoke x no args", `{{template "x"}}`, "TEXT", tVal, true},
	{"invoke dot int", `{{template "dot" .I}}`, "17", tVal, true},
	{"invoke dot []int", `{{template "dot" .SI}}`, "[3 4 5]", tVal, true},
	{"invoke dotV", `{{template "dotV" .U}}`, "v", tVal, true},
	{"invoke nested int", `{{template "nested" .I}}`, "17", tVal, true},

        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":