return setter.getGenericParameterTypes()[0];
        }

        @Override
        public void setValue(Object target, Object value) {
            JavaMethod.of(Object.class, setter).invoke(target, value);
        }
    }

    private static class PropertyFieldSetter implements PropertySetter {
        private final Method getter;
        private final Field field;

    unknown = 12
}
"""

        expect:
        fails()
        failure.assertHasCause("Could not set unknown property 'unknown' for task ':help' of type org.gradle.configuration.Help.")
    }

    def "reports invoke unknown method from configure closure"() {
        settingsFile << "rootProject.name = 'test'"
        buildFile << """
tasks.help {
    unknown(12)
}
"""

        expect:
        fails()

            "daemonOpts=" +
            (
                "--add-opens=java.base/java.util=ALL-UNNAMED," +
                    "--add-opens=java.base/java.lang=ALL-UNNAMED," +
                    "--add-opens=java.base/java.lang.invoke=ALL-UNNAMED," +
                    "--add-opens=java.prefs/java.util.prefs=ALL-UNNAMED," +
                    "--add-opens=java.base/java.nio.charset=ALL-UNNAMED," +

		})
		defer cb2.Release()
		return cb2.Invoke()
	})
	defer cb.Release()
	if got := cb.Invoke().Int(); got != 42 {
		t.Errorf("got %#v, want %#v", got, 42)
	}
	if !called {
		t.Error("function not called")
	}
}

func TestInterleavedFunctions(t *testing.T) {
	c1 := make(chan struct{})
	c2 := make(chan struct{})

	js.Global().Get("setTimeout").Invoke(js.FuncOf(func(this js.Value, args []js.Value) any {

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

        }

        Method method = obj.getClass().getMethod(methodName);
        Object result = method.invoke(obj);
        if (result == null) {
            return null;
        } else {
            return targetClass.cast(result);
        }
    }

    /**
     * Utility method to invoke a method on an object by reflective means.
     *
     * @return the result of the method invocation as an {@link Object}

                        .invoke(null, plugins)!!

                val myOwnPluginGroup =
                    getDeclaredMethod("getOwn", myPluginGroup.javaClass)
                        .invoke(null, myPluginGroup)!!

                val actualPluginSpec =
                    getDeclaredMethod("getPlugin", myOwnPluginGroup.javaClass)
                        .invoke(null, myOwnPluginGroup) as PluginDependencySpec

    if command -v systemctl >/dev/null; then
        systemctl --no-reload stop fess.service > /dev/null 2>&1 || true

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

    # older suse linux distributions do not ship with systemd
    # but do not have an /etc/init.d/ directory

\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
\tat java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
\tat java.base/java.lang.reflect.Method.invoke(Method.java:564)
\tat org.gradle.internal.reflect.JavaMethod.invoke(JavaMethod.java:104)

  }

  private Throwable tryInternalFastPathGetFailure(Future<?> future) throws Exception {
    Method tryInternalFastPathGetFailureMethod =
        abstractFutureClass.getDeclaredMethod("tryInternalFastPathGetFailure");
    tryInternalFastPathGetFailureMethod.setAccessible(true);
    return (Throwable) tryInternalFastPathGetFailureMethod.invoke(future);
  }