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

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

    }

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

	if err := Configure(o); err != nil {
		t.Errorf("Expecting success, got %v", err)
	} else if s.GetOutputLevel() != InfoLevel {
		t.Errorf("Expecting InfoLevel, got %v", s.GetOutputLevel())
	}

	o = DefaultOptions()
	o.stackTraceLevels = "default:debug,all:info"
	if err := Configure(o); err != nil {
		t.Errorf("Expecting success, got %v", err)
	} else if s.GetStackTraceLevel() != InfoLevel {

        assertDynamicInterpretationOf(
            """java""",
            "Expecting token of type RBRACE, but got IDENTIFIER ('java') instead"
        )
    }

    @Test
    fun `unsupported syntax - version catalog alias`() {
        assertDynamicInterpretationOf(
            """alias(libs.plugins.jmh)""",
            "Expecting token of type RBRACE, but got IDENTIFIER ('alias') instead"
        )
    }

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