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 {

	}
}

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())

				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),
			},

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

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

	defer cancel()
	StartPriorityAndFairnessWatermarkMaintenance(ctx.Done())

	// send a watch request to test skipping long running request
	if err := expectHTTPGet(fmt.Sprintf("%s/api/v1/foos/foo/proxy", server.URL), http.StatusOK); err != nil {
		// request should not be rejected
		t.Error(err)
	}
}

func TestApfRejectRequest(t *testing.T) {
	server := newApfServerWithSingleRequest(t, decisionReject)

         sourceFile("cpp/foo2", "foo.cpp", """
            #include <iostream>
            #include "foo.h"
            using namespace std;

            void foo2() {
                cout << "foo2";
            }
        """)]
    }

    @Override
    List<SourceFile> getHeaderFiles() {
        [sourceFile("headers", "foo.h", """
           void foo1();
           void foo2();
           """)
         ]