// license that can be found in the LICENSE file.

// Verify that pointer method calls are caught during typechecking.
// Reproducer extracted and adapted from method.go

package foo

type A struct {
	B
}
type B int

func (*B) g() {}

var _ = func() {
	var a A
	A(a).g() // ERROR "cannot call pointer method .*on|cannot take the address of"

type Outer struct{ *Inner }
type Inner struct{ s string }

func (i Inner) M() string { return i.s }

func main() {
	// method expressions with named receiver types
	I.m(S{})
	want += " m()"

	S.m1(S{}, "a")
	want += " m1(a)"

	// method expressions with literal receiver types
	f := interface{ m1(string) }.m1
	f(S{}, "b")
	want += " m1(b)"

	interface{ m1(string) }.m1(S{}, "c")

Method <org.gradle.api.plugins.BasePlugin.configureConfigurations(org.gradle.api.Project)> calls method <org.gradle.api.internal.artifacts.configurations.RoleBasedConfigurationContainerInternal.maybeCreateConsumableUnlocked(java.lang.String)> in (BasePlugin.java:0)

        then:
        result[0].method == method1
        result[0].arguments == [1, 2] as Object[]
        result[1].method == method1
        result[1].arguments == [3, 4] as Object[]
        serialized.length < invocation1Serialized.length + invocation2Serialized.length
    }

    def "serializes method invocations for multiple methods"() {
        def method1 = String.class.getMethod("substring", Integer.TYPE, Integer.TYPE)

    interface Item4 {
    }

    interface Item5 {
    }

    interface SuperThing {
        Runnable method1();

        List<Item1> method2();

        Map<Set<Item2>, String> method3();
    }

    interface GenericThing {
        Item3[] method1(String p);
        List<Item5>[] method2(String p);
    }

    interface Thing extends SuperThing, GenericThing {
        <T extends Item4> List<T> get();

apiVersion: gateway.networking.k8s.io/v1beta1
kind: HTTPRoute
metadata:
  name: invalid-method
spec:
  rules:
  - matches:

#$ Used in:
#$ - geps/gep-1748.md
kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: api
spec:
  parentRefs:
  - name: api-gw
  rules:
  - matches:
    - method: POST
    - method: PUT
    - method: DELETE
    backendRefs:
    - group: multicluster.x-k8s.io
      kind: ServiceImport
      name: api-primary
      port: 8080
  - backendRefs:
    - group: multicluster.x-k8s.io

Akshay J Nambiar <******@****.***> 1683529381 +0530

        def class1 = new TestClassResult(1, 'Class1', 1234)
        def method1 = new TestMethodResult(1, "method1", TestResult.ResultType.SUCCESS, 100, 2300)
        def method2 = new TestMethodResult(2, "method2", TestResult.ResultType.FAILURE, 200, 2700).addFailure("message", "stack-trace", "ExceptionType")
        class1.add(method1)
        class1.add(method2)
        def class2 = new TestClassResult(2, 'Class2', 5678)

// A type can be passed to a plugin and converted to interface
// there. So its methods need to be live.

package main

import (
	"plugin"

	"testplugin/method2/p"
)

var t p.T

type I interface{ M() }

func main() {
	pl, err := plugin.Open("method2.so")
	if err != nil {
		panic(err)
	}

	f, err := pl.Lookup("F")
	if err != nil {
		panic(err)
	}