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

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

// license that can be found in the LICENSE file.

package main

func f(int, int) {
    switch x {
    case 1:
        f(1, g()   // ERROR "expecting \)|possibly missing comma or \)"
    case 2:
        f()
    case 3:
        f(1, g()   // ERROR "expecting \)|possibly missing comma or \)"
    }

	fmt.Println("finished")
}

func expectError(expectLine int) {
	if recover() == nil {
		panic("did not crash")
	}
	for i := 1;; i++ {
		_, file, line, ok := runtime.Caller(i)
		if !ok {
			panic("cannot find issue4562.go on stack")
		}
		if strings.HasSuffix(file, "issue4562.go") {
			if line != expectLine {
				panic(fmt.Sprintf("crashed at line %d, wanted line %d", line, expectLine))
			}
			break
		}
	}

			}
			funcs.Store(pt)

			if c.debugEnabled != DebugEnabled() {
				t.Errorf("Got %v, expecting %v", DebugEnabled(), c.debugEnabled)
			}

			if c.infoEnabled != InfoEnabled() {
				t.Errorf("Got %v, expecting %v", InfoEnabled(), c.infoEnabled)
			}

			if c.warnEnabled != WarnEnabled() {
				t.Errorf("Got %v, expecting %v", WarnEnabled(), c.warnEnabled)
			}

			if c.errorEnabled != ErrorEnabled() {