def rawAction = Mock(Action<? super ExecutionListener>)

        when:
        def commandLineExecution = factory.convert(["--some-option"])
        commandLineExecution.execute(executionListener)

        then:
        1 * actionFactory1.configureCommandLineParser(!null) >> {
            CommandLineParser parser -> parser.option("some-option")
        }

        this.testResultsFile = testResultsFile
        final XmlParser parser = new XmlParser(false, false)
        parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
        parser.setFeature("http://xml.org/sax/features/namespaces", false)
        parser.setFeature("http://apache.org/xml/features/disallow-doctype-decl", false)
        this.resultsNode = parser.parse(testResultsFile)

    if (parser->parseOptionalOperand(operand_type).has_value()) {
      packed_inputs->emplace_back(operand_type);
      if (parser->parseKeyword("as",
                               " between packed input and block argument") ||
          parser->parseOperand(packed_region_args.emplace_back(),
                               /*allowResultNumber=*/false) ||

        TemporaryFileProvider temporaryFileProvider,
        BuildCacheEntryPacker packer
    ) {
        super(
            startParameter,
            buildOperationRunner,
            originMetadataFactory,
            stringInterner
        );
        this.temporaryFileProvider = temporaryFileProvider;
        this.packer = packer;
        this.buildOperationProgressEmitter = buildOperationProgressEmitter;
    }

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

class Callback {
public:
	virtual ~Callback() { }
	virtual std::string run() { return "Callback::run"; }
};

class Caller {
private:
	Callback *callback_;
public:
	Caller(): callback_(0) { }
	~Caller() { delCallback(); }
	void delCallback() { delete callback_; callback_ = 0; }
	void setCallback(Callback *cb) { delCallback(); callback_ = cb; }
	std::string call();

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// To avoid a cyclic dependency with go/parser, this file is in a separate package.

package ast_test

import (
	"fmt"
	. "go/ast"
	"go/parser"
	"go/token"
	"sort"
	"strings"
	"testing"
)

const src = `
// the very first comment

// package p
package p /* the name is p */

	// Note these errors should be independent of the architecture.
	// Just run the test with amd64.
	parser := newParser("amd64")
	var buf strings.Builder
	parser.errorWriter = &buf

	for _, cat := range testcats {
		for _, test := range cat.tests {
			parser.allowABI = cat.allowABI
			parser.errorCount = 0
			parser.lineNum++
			if !parser.pseudo(test.pseudo, tokenize(test.operands)) {
				t.Fatalf("Wrong pseudo-instruction: %s", test.pseudo)

	if _, err := c.Write(b); err != nil {
		return dnsmessage.Parser{}, dnsmessage.Header{}, err
	}

	b = make([]byte, maxDNSPacketSize)
	for {
		n, err := c.Read(b)
		if err != nil {
			return dnsmessage.Parser{}, dnsmessage.Header{}, err
		}
		var p dnsmessage.Parser
		// Ignore invalid responses as they may be malicious

	if authCtx.GrpcContext != nil {
		return cca.authenticateGrpc(authCtx.GrpcContext)
	}
	if authCtx.Request != nil {
		return cca.authenticateHTTP(authCtx.Request)
	}
	return nil, nil
}

func (cca *ClientCertAuthenticator) authenticateGrpc(ctx context.Context) (*security.Caller, error) {
	peer, ok := peer.FromContext(ctx)

        final DOMParser parser = getDomParser();
        try (final Reader reader = new StringReader(content)) {
            parser.parse(new InputSource(reader));
        } catch (final Exception e) {
            logger.warn("Failed to parse the content.", e);
            return new ExtractData(extractString(content));
        }

        final Document document = parser.getDocument();
        try {