* fun test() {
     *   val action = foo()
     *   action("") // this call
     * }
     * ```
     *
     * Unfortunately, [symbol] for the `action("")` call will be pointing to the `Function1<P1, R>.invoke(p1: P1): R`, because we
     * intentionally unwrap use-site substitution overrides. Because of this, `symbol.name` will yield `"p1"`, and not `"bar"`.
     *

 * {@code default} methods were introduced</a>. For newer methods, like {@code forEach}, it inherits
 * their default implementations. When those implementations invoke methods, they invoke methods on
 * the {@code ForwardingConcurrentMap}.
 *
 * @author Charles Fry
 * @since 2.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault

}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION
// CODE_FRAGMENT_CLASS_NAME: MyCodeFragment
// CODE_FRAGMENT_METHOD_NAME: invoke

        when:
        obj.invokeMethod("m", [new Date()] as Object[])

        then:
        MissingMethodException e = thrown()
        e.method == "m"
    }

    def "can invoke custom closure implementation"() {
        def cl = new Closure(this, this) {
            @Override
            Object call(Object... args) {
                return "result"
            }
        }

        public String toString() {
          throw new AssertionFailedError();
        }
      };

  private static class Message {
    boolean invoked;

    @Override
    public String toString() {
      assertFalse(invoked);
      invoked = true;
      return "A message";
    }
  }

  private static final String FORMAT = "I ate %s pies.";

import org.objectweb.asm.Type;
import org.objectweb.asm.commons.CodeSizeEvaluator;

import javax.annotation.Nullable;
import java.lang.invoke.CallSite;
import java.lang.invoke.LambdaMetafactory;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.SerializedLambda;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

	{"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},

    java.lang.Exception: ouch
        at org.ClassName1.methodName1(FileName1.java:11)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at org.ClassName2.methodName2(FileName2.java:22)
        at ClassName.testName(MyTest.java:22)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at org.ClassName3.methodName3(FileName3.java:33)
"""
    }

  "ModuleOp"> {
  let summary = "generate a temporary file and invoke InitTextFileToImportPass";
  let constructor = "::mlir::tf_test::CreateInitTextFileToImportTestPass()";
}

def InitTextFileToImportSavedModelTestPass : Pass<"tf-init-text-file-to-import-saved-model-test",
  "ModuleOp"> {
  let summary = "mimick a saved model and invoke InitTextFileToImportPass";

    Prepender prepender = delegate.invoke(null, "a", 1);
    assertEquals("a", prepender.prefix);
    assertEquals(1, prepender.times);
  }

  public void testConstructor_returning() throws Exception {
    Invokable<?, Prepender> delegate =
        Prepender.constructor(String.class, int.class).returning(Prepender.class);
    Prepender prepender = delegate.invoke(null, "a", 1);
    assertEquals("a", prepender.prefix);