}
	}
}

const listTypeResourceSchema = `
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: foos.test
spec:
  group: test
  names:
    kind: Foo
    listKind: FooList
    plural: foos
    singular: foo
  scope: Cluster
  versions:
  - name: v1
    schema:
      openAPIV3Schema:
        type: object
        properties:

				Schema:  fixtures.AllowAllSchema(),
			},
		},
		Names: apiextensionsv1.CustomResourceDefinitionNames{
			Plural:   "foos",
			Singular: "foo",
			Kind:     "Foo",
			ListKind: "FooList",
		},
		Scope: apiextensionsv1.ClusterScoped,
	},
}

const (
	// structural schema because x-kubernetes-list-type is only allowed for those
	listTypeResourceSchema = `
type: object
properties:
  correct-map:

    }
  }
  function {
    signature {
      name: "foo4"
    }
  }
  function {
    signature {
      name: "foo5"
    }
  }
  function {
    signature {
      name: "foo6"
    }
  }
  function {
    signature {
      name: "foo7"
    }
  }
  function {
    signature {
      name: "foo8"
    }
  }
  function {
    signature {
      name: "foo9"
    }

//
// 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
}

	}
}

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

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

         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();
           """)
         ]

            #include <stdio.h>
            #include "foo.h"
            int main () {
               foo1();
               foo2();
               return 0;
            }
        """),

        sourceFile("c/foo1", "foo.c", """
            #include <stdio.h>
            #include "foo.h"

            void foo1() {
                printf("foo1");
            }
        """),