e := len(p) - 1
	if strings.Contains(protoPackage, "sigs.k8s.io/gateway-api") {
		// Gateway has one level of nesting with custom name
		return "Gateway" + strcase.UpperCamelCase(p[e])
	}
	// rest have two levels of nesting
	return strcase.UpperCamelCase(p[e-1]) + strcase.UpperCamelCase(p[e])
}

type packageImport struct {
	PackageName string
	ImportName  string
}

func toImport(p string) string {

	}()

	for _, sigHash := range defaultSupportedSignatureAlgorithms {
		t.Run(fmt.Sprintf("%v", sigHash), func(t *testing.T) {
			serverConfig := testConfig.Clone()
			serverConfig.Certificates = make([]Certificate, 1)

			testingOnlyForceClientHelloSignatureAlgorithms = []SignatureScheme{sigHash}

			sigType, _, _ := typeAndHashFromSignatureScheme(sigHash)
			switch sigType {

// ensuring the hash does not change when a pointer changes.
func DeepHashObject(hasher hash.Hash, objectToWrite interface{}) {
	hasher.Reset()
	fmt.Fprintf(hasher, "%v", dump.ForHash(objectToWrite))

	"fmt"

	"sigs.k8s.io/yaml"

	"istio.io/istio/pkg/config/validation"
	// Force-import a function.
	_ "istio.io/istio/pkg/config/validation/envoyfilter"
	"istio.io/istio/pkg/util/sets"
	"istio.io/istio/pkg/util/strcase"
)

// Metadata is the top-level container.
type Metadata struct {
	Resources []*Resource `json:"resources"`
}

var _ json.Unmarshaler = &Metadata{}

        hasher.putString(getClass().getName());
    }

    @Override
    Optional<HashCode> tryHash(RegularFileSnapshotContext snapshotContext) {
        return Optional.of(snapshotContext)
            .flatMap(IoFunction.wrap(this::hashContent));
    }

    @Override
    Optional<HashCode> tryHash(ZipEntryContext zipEntryContext) {
        return Optional.of(zipEntryContext)

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

// Package dirhash defines hashes over directory trees.
// These hashes are recorded in go.sum files and in the Go checksum database,
// to allow verifying that a newly-downloaded module has the expected content.
package dirhash

import (
	"archive/zip"
	"crypto/sha256"
	"encoding/base64"
	"errors"
	"fmt"
	"io"
	"os"

	// Tests hashing order to be consistent.
	for i, testCase := range testCases {
		if sipHashElement := hashKey("SIPMOD", testCase.objectName, 200, testUUID); sipHashElement != testCase.sipHash {
			t.Errorf("Test case %d: Expected \"%v\" but failed \"%v\"", i+1, testCase.sipHash, sipHashElement)
		}
	}

	if sipHashElement := hashKey("SIPMOD", "This will fail", -1, testUUID); sipHashElement != -1 {

    @Override
    boolean filter(ZipEntryContext context) {
        return !context.getEntry().isDirectory() && matchesAnyFilters(context.getRelativePathSegments());
    }

    @Override
    public Optional<HashCode> tryHash(RegularFileSnapshotContext snapshotContext) {
        return Optional.ofNullable(matchingFiltersFor(snapshotContext.getRelativePathSegments()))
            .map(resourceEntryFilter -> {

	sigType, sigHash, err := typeAndHashFromSignatureScheme(hs.sigAlg)
	if err != nil {
		return c.sendAlert(alertInternalError)
	}

	signed := signedMessage(sigHash, serverSignatureContext, hs.transcript)
	signOpts := crypto.SignerOpts(sigHash)
	if sigType == signatureRSAPSS {
		signOpts = &rsa.PSSOptions{SaltLength: rsa.PSSSaltLengthEqualsHash, Hash: sigHash}
	}

	}
	sigType, sigHash, err := typeAndHashFromSignatureScheme(certVerify.signatureAlgorithm)
	if err != nil {
		return c.sendAlert(alertInternalError)
	}
	if sigType == signaturePKCS1v15 || sigHash == crypto.SHA1 {
		c.sendAlert(alertIllegalParameter)
		return errors.New("tls: certificate used with invalid signature algorithm")
	}
	signed := signedMessage(sigHash, serverSignatureContext, hs.transcript)