* The implementation may choose to delegate to the original Groovy implementation by returning the value of {@code invocation.callOriginal()}.
     *
     * @param invocation the arguments supplied by the caller
     * @param consumer the class that invokes the intercepted call
     * @return the value to return to the caller

                      absl::string_view prefix_to_strip,
                      protobuf::Message* parsed_proto) {
  protobuf::TextFormat::Parser parser;
  // Don't produce errors when attempting to parse text format as it would fail
  // when the input is actually a binary file.
  NoOpErrorCollector collector;
  parser.RecordErrorsTo(&collector);
  // Attempt to parse as text.
  absl::string_view text_proto_without_prefix = text_proto;

	}
}

// cannot initialize in init because (printer) Fprint launches goroutines.
func initialize() {
	const filename = "testdata/parser.go"

	src, err := os.ReadFile(filename)
	if err != nil {
		log.Fatalf("%s", err)
	}

	file, err := parser.ParseFile(fset, filename, src, parser.ParseComments)
	if err != nil {
		log.Fatalf("%s", err)
	}

	var buf bytes.Buffer
	testprint(&buf, file)

    }

    private goodGrammar() {
        file("grammar-builder/src/main/antlr/TestGrammar.g") << """
            header {
                package org.acme;
            }

            class TestGrammar extends Parser;

            options {
                buildAST = true;
            }

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

            mexpr
                :   atom (STAR^ atom)*

    }

    public ComponentModuleMetadataDetails module(final Object sourceModule) {
        final NotationParser<Object, ModuleIdentifier> parser = parser(moduleIdentifierFactory);
        final ModuleIdentifier source = parser.parseNotation(sourceModule);
        return new ComponentModuleMetadataDetails() {

            @Override
            public void replacedBy(Object moduleNotation) {

// Authenticate extracts identities from Xfcc Header.
func (xff XfccAuthenticator) Authenticate(ctx security.AuthContext) (*security.Caller, error) {
	remoteAddr := ctx.RemoteAddress()
	xfccHeader := ctx.Header(xfccparser.ForwardedClientCertHeader)
	if len(remoteAddr) == 0 || len(xfccHeader) == 0 {
		return nil, fmt.Errorf("caller from %s does not have Xfcc header", remoteAddr)
	}

import org.gradle.nativeplatform.NativeLibraryRequirement;

public class RequirementParsingNativeDependencyResolver implements NativeDependencyResolver {
    private final NotationParser<Object, NativeLibraryRequirement> parser = NativeDependencyNotationParser.parser();

    private final NativeDependencyResolver delegate;

    public RequirementParsingNativeDependencyResolver(NativeDependencyResolver delegate) {
        this.delegate = delegate;
    }

    echo "message:${message}"
    echo "has not:${match}"
    caller
    return 1
  fi
}

kube::test::if_has_not_string() {
  local message=$1
  local match=$2

  if grep -q "${match}" <<< "${message}"; then
    echo -n "${bold}${red}"
    echo "FAIL!"
    echo -n "${reset}"
    echo "message:${message}"
    echo "has:${match}"
    caller
    return 1
  else
    echo -n "${green}"

/// Parse a type registered to this dialect.
Type FallbackDialect::parseType(DialectAsmParser &parser) const {
  StringRef keyword;
  if (parser.parseKeyword(&keyword)) return Type();

  if (keyword == "tf_tensor") return TFTensorType::get(getContext());
  if (keyword == "tf_allocator") return TFAllocatorType::get(getContext());

  parser.emitError(parser.getNameLoc(), "unknown type: ") << keyword;
  return Type();
}

	return strings.HasPrefix(a, "kubernetes.default.svc")
}

// Authenticate authenticates the call using the K8s JWT from the context.
// The returned Caller.Identities is in SPIFFE format.
func (a *KubeJWTAuthenticator) Authenticate(authRequest security.AuthContext) (*security.Caller, error) {
	if authRequest.GrpcContext != nil {
		return a.authenticateGrpc(authRequest.GrpcContext)
	}
	if authRequest.Request != nil {