// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

/*
void foo1(void) {}
void foo2(void* p) {}
*/
import "C"
import (
	"fmt"
	"os"
	"runtime"
	"strconv"
	"time"
	"unsafe"
)

func init() {
	register("CgoSignalDeadlock", CgoSignalDeadlock)
	register("CgoTraceback", CgoTraceback)

                [stdout writeData: strData];
            }
        """),
                sourceFile("objcpp/foo2", "foo.mm", """
            #import <iostream>
            #import "foo.h"

            void sayFoo2()
            {
                std::cout << "foo2";
            }
        """)]
    }

    @Override
    List<SourceFile> getHeaderFiles() {

            launcher.withTaskAndTestMethods(':included-build:test', "example.IncludedTest", ["foo2"])
        }
        then:
        assertTaskNotExecuted(":test")
        assertTaskExecuted(":included-build:test")
        assertTestExecuted(className: "example.IncludedTest", methodName: "foo2", task: ":included-build:test")
        assertTestNotExecuted(className: "example.IncludedTest", methodName: "foo")
    }

// in inlined functions.  Issue 3593.

package main

var did int

func main() {
	foo(side())
	foo2(side(), side())
	foo3(side(), side())
	T.m1(T(side()))
	T(1).m2(side())
	const want = 7
	if did != want {
		println("BUG: missing", want-did, "calls")
	}
}

func foo(_ int) {}
func foo2(_, _ int) {}
func foo3(int, int) {}
type T int
func (_ T) m1() {}
func (t T) m2(_ int) {}

# CHECK-LABEL:  func @main() {
# CHECK:    "tf.LegacyCall"() <{_disable_call_shape_inference = true, f = @foo0}> {device = ""}
# CHECK:    "tf.LegacyCall"() <{_disable_call_shape_inference = false, f = @bar0}> {device = ""}

# CHECK-LABEL:  func private @foo0()
# CHECK: "tf.LegacyCall"() <{_disable_call_shape_inference = false, f = @bar0}> {device = ""}

# the names are matching between the function definition and the uses / call
# site (a numerical suffix may be appended).

# CHECK: "tf.LegacyCall"(%outputs) <{_disable_call_shape_inference = false, f = @foo0}> {device = ""}

				{
					name:      "foo-sa",
					namespace: "foo-ns",
					tr: &authenticationv1.TokenRequest{
						Spec: authenticationv1.TokenRequestSpec{
							Audiences:         []string{"foo1", "foo2"},
							ExpirationSeconds: getInt64Point(2000),
							BoundObjectRef: &authenticationv1.BoundObjectReference{
								Kind: "pod",
								Name: "foo-pod",
								UID:  "foo-uid",
							},
						},

abstract class X<T> {
    fun <S> foo1(t: T): T = t
    fun <Q> foo2(t: T) {}
    fun <U> foo3() {}
}

        def foo1 = Attribute.of("foo", String)
        def foo2 = Attribute.of("foo", String)
        def attr3 = Attribute.of("baz", String)

        given:

        ImmutableAttributes[] candidates = [candidate(ImmutableMap.of(attr3, "v2", foo1, "v2"))]
        AttributeContainer requested = attribute(attr3, "v3")
        attributesSchema.getAttributeByName("foo") >> foo2

        when:

		{
			name: "create slice from endpoints with labels and annotations",
			tweakEndpoint: func(ep *v1.Endpoints) {
				labels := map[string]string{"foo": "bar"}
				ep.Labels = labels
				annotations := map[string]string{"foo2": "bar2"}
				ep.Annotations = annotations
			},
			expectedSlice: discovery.EndpointSlice{
				ObjectMeta: metav1.ObjectMeta{
					Labels: map[string]string{
						"foo":                      "bar",