s := cryptobyte.String(data)
	return s.Skip(1) &&
		readUint24LengthPrefixed(&s, &m.verifyData) &&
		s.Empty()
}

type certificateRequestMsg struct {
	// hasSignatureAlgorithm indicates whether this message includes a list of
	// supported signature algorithms. This change was introduced with TLS 1.2.
	hasSignatureAlgorithm bool

	certificateTypes             []byte

        given:
        def configuration = conf()

        when:
        configuration.getBuildDependencies()

        then:
        0 * _._
    }

    def "state indicates failure resolving graph"() {
        given:
        def configuration = conf()
        def failure = new TypedResolveException("dependencies", "configuration ':conf'", [new RuntimeException()])

        and:

			Package:    p,
			IgnoreFail: true, // run (prepare output) even if build failed
			TryCache:   rta.c.tryCache,
		}
		if writeCoverMetaAct != nil {
			// If writeCoverMetaAct != nil, this indicates that our
			// "go test -coverpkg" run actions will need to read the
			// meta-files summary file written by writeCoverMetaAct,
			// so add a dependence edge from writeCoverMetaAct to the
			// run action.

   *
   * <p>This method accepts an array with element type {@code @Nullable T}, but callers must pass an
   * array whose contents are initially non-null. The {@code @Nullable} annotation indicates that
   * this method will write nulls into the array during iteration.
   *
   * <p>This is mainly just to avoid the intermediate ArrayDeque in ConsumingQueueIterator.
   */

   *
   * <p>This method accepts an array with element type {@code @Nullable T}, but callers must pass an
   * array whose contents are initially non-null. The {@code @Nullable} annotation indicates that
   * this method will write nulls into the array during iteration.
   *
   * <p>This is mainly just to avoid the intermediate ArrayDeque in ConsumingQueueIterator.
   */

				c.watchersBuffer = append(c.watchersBuffer, watcher)
			}
		}
	} else {
		// supported equal to false generally means that trigger function
		// is not defined (or not aware of any indexes). In this case,
		// watchers filters should generally also don't generate any
		// trigger values, but can cause problems in case of some
		// misconfiguration. Thus we paranoidly leave this branch.

	DI_NOBROWSE DI_FLAGS = 0x00000200 // no Browse... in InsertDisk

	// Flags set by DiBuildDriverInfoList
	DI_MULTMFGS DI_FLAGS = 0x00000400 // Set if multiple manufacturers in class driver list

	// Flag indicates that device is disabled
	DI_DISABLED DI_FLAGS = 0x00000800 // Set if device disabled

	// Flags for Device/Class Properties
	DI_GENERALPAGE_ADDED  DI_FLAGS = 0x00001000
	DI_RESOURCEPAGE_ADDED DI_FLAGS = 0x00002000

	"errors"
	"fmt"
	"internal/goversion"
	"internal/testenv"
	"reflect"
	"regexp"
	"sort"
	"strings"
	"sync"
	"testing"

	. "cmd/compile/internal/types2"
)

// nopos indicates an unknown position
var nopos syntax.Pos

func mustParse(src string) *syntax.File {
	f, err := syntax.Parse(syntax.NewFileBase(pkgName(src)), strings.NewReader(src), nil, nil, 0)
	if err != nil {

		LockEnabled: objectLockEnabled,
		ForceCreate: forceCreate,
	}

	if globalDNSConfig != nil {
		sr, err := globalDNSConfig.Get(bucket)
		if err != nil {
			// ErrNotImplemented indicates a DNS backend that doesn't need to check if bucket already
			// exists elsewhere
			if err == dns.ErrNoEntriesFound || err == dns.ErrNotImplemented {
				// Proceed to creating a bucket.

	"go/ast"
	"go/importer"
	"go/parser"
	"go/token"
	"internal/goversion"
	"internal/testenv"
	"reflect"
	"regexp"
	"slices"
	"strings"
	"sync"
	"testing"

	. "go/types"
)

// nopos indicates an unknown position
var nopos token.Pos

func mustParse(fset *token.FileSet, src string) *ast.File {
	f, err := parser.ParseFile(fset, pkgName(src), src, parser.ParseComments)
	if err != nil {