//
// misspelled     x.foo   !=    Foo    type X has no field or method foo, but does have field Foo
// missing        x.foo   !=    FoO    type X has no field or method foo
// inaccessible   x.foo   !=    foo    cannot refer to unexported field foo
// missing        x.foo   !=    foO    type X has no field or method foo

type S struct {
	Foo1 int
	FoO2 int
	foo3 int
	foO4 int
}

			want:   labels,
		},
		{
			labels:     labels,
			labelKey:   "foo4",
			labelValue: "89",
			want: map[string]string{
				"foo1": "bar1",
				"foo2": "bar2",
				"foo3": "bar3",
				"foo4": "89",
			},
		},
		{
			labels:     nil,
			labelKey:   "foo4",
			labelValue: "12",
			want: map[string]string{
				"foo4": "12",
			},
		},
	}

	for _, tc := range cases {

				makeGCContainer("foo2", "bar2", 0, 0, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo3", "bar3", 1, 1, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo3", "bar3", 0, 0, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo4", "bar4", 1, 1, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo4", "bar4", 0, 0, runtimeapi.ContainerState_CONTAINER_EXITED),
			},

				constructResource("foo1", "foo1.bar.com", "192.1.1.11", "2"),
				constructResource("foo2", "foo2.bar.com", "192.1.1.22", "1"),
				constructResource("foo3", "foo3.bar.com", "192.1.1.3", ""),
			},
			expectedResources: [][]string{
				{"foo1", "foo1.bar.com", "192.1.1.11"},
				{"foo2", "foo2.bar.com", "192.1.1.2"},
				{"foo3", "foo3.bar.com", "192.1.1.3"},
			},
		},
		{

package main

func foo() (int, int) {
	return 2.3 // ERROR "not enough return values\n\thave \(number\)\n\twant \(int, int\)|not enough arguments to return"
}

func foo2() {
	return int(2), 2 // ERROR "too many (arguments to return|return values)\n\thave \(int, number\)\n\twant \(\)|return with value in function with no return type"
}

func foo3(v int) (a, b, c, d int) {
	if v >= 0 {

        def projectB = project(project, "b")

        def fooA = task("foo", project: projectA)
        def barA = task("bar", project: projectA)

        def fooB = task("foo", project: projectB)
        def barB = task("bar", project: projectB)

        when:
        addToGraphAndPopulate(fooA, barA, fooB, barB)
        def taskNode1 = selectNextTaskNode()
        def taskNode2 = selectNextTaskNode()

	}
}

func TestGetWork(t *testing.T) {
	q, clock := newTestBasicWorkQueue()
	q.Enqueue(types.UID("foo1"), -1*time.Minute)
	q.Enqueue(types.UID("foo2"), -1*time.Minute)
	q.Enqueue(types.UID("foo3"), 1*time.Minute)
	q.Enqueue(types.UID("foo4"), 1*time.Minute)
	expected := []types.UID{types.UID("foo1"), types.UID("foo2")}
	compareResults(t, expected, q.GetWork())
	compareResults(t, []types.UID{}, q.GetWork())

	// should register an add
	podUpdate := CreatePodUpdate(kubetypes.ADD, TestSource, CreateValidPod("foo", "new"), CreateValidPod("foo2", "new"), CreateValidPod("foo3", "new"))
	channel <- podUpdate
	expectPodUpdate(t, ch, CreatePodUpdate(kubetypes.ADD, TestSource, CreateValidPod("foo", "new"), CreateValidPod("foo2", "new"), CreateValidPod("foo3", "new")))

	// should ignore ADDs that are identical
	expectNoPodUpdate(t, ch)

fun <S> foo1(t: Int): Int fromClass Y
  S from /Y.foo1
  t: Int from /Y.foo1

fun <Q> foo2(t: Int) fromClass Y
  Q from /Y.foo2
  t: Int from /Y.foo2

fun <U> foo3() fromClass X
  U from /X.foo3

fun equals(other: Any?): Boolean fromClass kotlin/Any
  other: Any? from kotlin/Any.equals

fun hashCode(): Int fromClass kotlin/Any

fun toString(): String fromClass kotlin/Any

				{
					EnvVar: v1.EnvVar{Name: "Foo1", Value: "Bar1"},
				},
				{
					EnvVar: v1.EnvVar{Name: "Foo2", Value: "Bar2"},
				},
			},
			extraEnv: []kubeadmapi.EnvVar{
				{
					EnvVar: v1.EnvVar{Name: "Foo3", Value: "Bar3"},
				},
			},
			mergedEnv: []v1.EnvVar{
				{Name: "Foo1", Value: "Bar1"},
				{Name: "Foo2", Value: "Bar2"},
				{Name: "Foo3", Value: "Bar3"},
			},
		},
		{