thrown(UnsupportedNotationException)

        when:
        parser().parseNotation(null)

        then:
        thrown(UnsupportedNotationException)
    }

    def "single parser understands String notation"() {
        //just smoke testing the single parser, it is covered in multiParser, too.
        when:
        def v = parser().parseNotation("org.foo:bar:1.0")

        then:

   * exception is propagated to the caller exactly as-is. If, on the other hand, the time limit is
   * reached, the proxy will attempt to abort the call to the target, and will throw an {@link
   * UncheckedTimeoutException} to the caller.
   *
   * <p>It is important to note that the primary purpose of the proxy object is to return control to

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.DescriptorParseContext;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.DisconnectedDescriptorParseContext;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.DisconnectedIvyXmlModuleDescriptorParser;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.IvyModuleDescriptorConverter;

        "vararg"        | "Groovy dynamic dispatch" | { testVararg(it, it, it) }    | true           | "testVararg(Object...)"
    }

    def 'access to a #kind of a Groovy property from a #caller caller is intercepted as #expected for multiple types with the same method names'() {
        when:
        def firstIntercepted = interceptedInterceptorTestReceiver(shouldDelegate, invocation)

	"a"

	_ "b"

	_ "c"
	"d"
)`,
			want: []string{"a", "b", "c"},
		},
	} {
		t.Run(test.name, func(t *testing.T) {
			fset := token.NewFileSet()
			file, err := parser.ParseFile(fset, "test.go", strings.NewReader(test.in), parser.ParseComments)
			if err != nil {
				t.Fatal(err)
			}
			imps := findImportGroupStarts1(file.Imports)
			got := make([]string, len(imps))
			for i, imp := range imps {

	}
}

func (f *FakeAuthenticator) Authenticate(authCtx AuthContext) (*Caller, error) {
	if authCtx.GrpcContext != nil {
		return f.authenticateGrpc(authCtx.GrpcContext)
	}
	if authCtx.Request != nil {
		return f.authenticateHTTP(authCtx.Request)
	}
	return nil, nil
}

func (f *FakeAuthenticator) authenticateHTTP(req *http.Request) (*Caller, error) {
	return nil, errors.New("not implemented")
}

    def "parses package information when defined in a separate line"() {
        given:
        def grammar = """
        header {
            package org.acme;
        }

        class TestGrammar extends Parser;

        options {
            buildAST = true;
        }

        expr:   mexpr (PLUS^ mexpr)* SEMI!
            ;

        mexpr
            :   atom (STAR^ atom)*
            ;

    }

    def 'access to a #kind of a Groovy property from a #caller caller is intercepted as #expected'() {
        when:
        def intercepted = interceptedWhen(shouldDelegate, invocation)

        then:
        intercepted == expected

        where:
        kind                  | caller      | expected                                      | invocation                           | shouldDelegate

                maybeApplyInterceptor(ccs, caller, flags, interceptors.get(InterceptScope.readsOfPropertiesNamed(name)));
                break;
            case "init":
                maybeApplyInterceptor(ccs, caller, flags, dispatchingConstructorInterceptor);
                break;
        }
        return ccs;
    }

public class TaskOutputPackagingTarBenchmark extends AbstractTaskOutputPackagingBenchmark {
    @Param({"tar", "tar.commons", "tar.jtar"})
    String packer;

    @Param({"direct", "buffered"})
    String accessor;

    @Override
    protected String getPackerName() {
        return packer;
    }

    @Override
    protected String getAccessorName() {
        return accessor;
    }