v := runtime.NewCoercingMultiGroupVersioner(tc.target, tc.preferredKinds...)
			kind, ok := v.KindForGroupVersionKinds(tc.kinds)
			if !ok {
				t.Error("got no kind")
			}
			if kind != tc.expectKind {
				t.Errorf("expected %#v, got %#v", tc.expectKind, kind)
			}
			if e, a := tc.expectedId, v.Identifier(); e != a {
				t.Errorf("unexpected identifier: %s, expected: %s", a, e)
			}
		})
	}
}

type mockEncoder struct{}

internal
val LighterASTNode.isUseful: Boolean
    get() = !(COMMENTS.contains(tokenType) || tokenType == WHITE_SPACE || tokenType == SEMICOLON)


internal
fun LighterASTNode.expectKind(expected: IElementType) {
    check(isKind(expected))
}


internal
fun List<LighterASTNode>.expectSingleOfKind(expected: IElementType): LighterASTNode =
    this.single { it.isKind(expected) }

	type entry struct{ address, sa, network, version string }
	const name, port = "remote-we-svc", 80
	serviceCases := []struct {
		name, k8s, cfg string
		expectKind     workloadKind
	}{
		{
			expectKind: Pod,
			name:       "Service",
			k8s: `
---
apiVersion: v1
kind: Service
metadata:
  name: remote-we-svc
  namespace: test
spec:
  ports:
  - port: 80

		list       bool
		expected   runtime.Object
		expectKind schema.GroupVersionKind
		statusCode int
	}{
		{
			accept:     "application/json;as=PartialObjectMetadata;v=v1alpha1;g=meta.k8s.io",
			statusCode: http.StatusNotAcceptable,
		},
		{
			accept:     "application/json;as=PartialObjectMetadata;v=v1alpha1;g=meta.k8s.io, application/json",

        check(blockNodes.size >= 2) // first and last nodes are the opening an¡¡d closing braces

        val openBrace = blockNodes.first()
        openBrace.expectKind(LBRACE)

        val closingBrace = blockNodes.last()
        closingBrace.expectKind(RBRACE)

        return blockNodes.slice(1..blockNodes.size - 2)
    }

    private

	err := 0
	var t TT
	if a("1")("2")("3"); log != "a(1)a(2)a(3)" {
		println("expecting a(1)a(2)a(3) , got ", log)
		err++
	}
	log = ""

	if t.a("1").a(t.b("2")); log != "a(1)b(2)a(2)" {
		println("expecting a(1)b(2)a(2), got ", log)
		err++
	}
	log = ""
	if a("3")(b("4"))(b("5")); log != "a(3)b(4)a(4)b(5)a(5)" {
		println("expecting a(3)b(4)a(4)b(5)a(5), got ", log)
		err++
	}
	log = ""
	var i I = T1(0)

        val parser = combinator.symbol("foo") * combinator.symbol("bar")
        assertFailure(parser("foo"), "Expecting symbol 'bar'")
        assertFailure(parser("bar"), "Expecting symbol 'foo', but got 'bar' instead")
        assertFailure(parser("foobar"), "Expecting symbol 'foo', but got 'foobar' instead")
    }

    private
    fun assertFailure(parse: ParserResult<*>, reason: String) {

    fun `given a single id, it should create a single request with no version`() {
        expecting(plugin(id = "plugin-id")) {
            id("plugin-id")
        }
    }

    @Test
    fun `given a single id and apply value, it should create a single request with no version`() {
        listOf(true, false).forEach { applyValue ->
            expecting(plugin(id = "plugin-id", isApply = applyValue)) {

		frame, more := ci.Next()
		frames = append(frames, frame)
		if !more {
			break
		}
	}
	expecting := []string{
		"test/mysync.(*WaitGroup).Add",
		"test/mysync.(*WaitGroup).Done",
	}
	for i := 0; i < 2; i++ {
		if frames[i].Function != expecting[i] {
			log.Fatalf("frame %d: got %s, want %s", i, frames[i].Function, expecting[i])
		}
	}

    }

    @Override
    public boolean expecting(HttpExchange exchange) {
        lock.lock();
        try {
            if (current != null) {
                return current.expecting(exchange);
            }
            for (TrackingHttpHandler handler : available) {
                if (handler.expecting(exchange)) {
                    return true;
                }
            }