}

	return finishedHash{sha1.New(), sha1.New(), md5.New(), md5.New(), buffer, version, prf}
}

// A finishedHash calculates the hash of a set of handshake messages suitable
// for including in a Finished message.
type finishedHash struct {
	client hash.Hash
	server hash.Hash

	// Prior to TLS 1.2, an additional MD5 hash is required.
	clientMD5 hash.Hash
	serverMD5 hash.Hash

    }

    try {
      if (pong != null) {
        writer!!.writePong(pong)
      } else if (messageOrClose is Message) {
        val message = messageOrClose as Message
        writer!!.writeMessageFrame(message.formatOpcode, message.data)
        synchronized(this) {
          queueSize -= message.data.size.toLong()
        }
      } else if (messageOrClose is Close) {
        val close = messageOrClose as Close

absl::StatusOr<std::vector<std::string>> ListDirectory(
    absl::string_view directory);

template <class MessageT>
absl::StatusOr<MessageT> ReadBinaryProto(const std::string& binary_file_path) {
  MessageT message;
  TF_RETURN_IF_ERROR(
      tsl::ReadBinaryProto(tsl::Env::Default(), binary_file_path, &message));
  return message;
}

}  // namespace stablehlo::quantization::io

            .nagUser();

        then:
        def events = outputEventListener.events
        events.size() == 1
        events[0].message.startsWith("foo has been deprecated. This is scheduled to be removed in Gradle 9.0. bar.")
    }

    def "reports suppressed deprecation messages with --warning-mode summary"() {
        given:

    /**
     * Returns the flags currently in use for this message.
     *
     * @return An <code>int</code> containing the flags in use for this
     *         message.
     */
    public int getFlags () {
        return this.flags;
    }


    /**
     * Sets the flags for this message.
     *
     * @param flags
     *            The flags for this message.
     */
    public void setFlags ( int flags ) {

	"google.golang.org/protobuf/proto"

	"istio.io/istio/pkg/util/protomarshal"
)

// MessageSlice allows us to marshal slices of protobuf messages like clusters/listeners/routes/endpoints correctly
type MessageSlice []proto.Message

// MarshalJSON handles marshaling of slices of proto messages
func (pSlice MessageSlice) MarshalJSON() ([]byte, error) {
	buffer := bytes.NewBufferString("[")
	sliceLength := len(pSlice)

		})
	}
	oldmsgs := map[string]diag.Messages{}
	pushFn := func(combinedKinds sets.Set[config.GroupVersionKind]) {
		res, err := c.analyzer.ReAnalyzeSubset(combinedKinds, stop)
		if err != nil {
			log.Errorf("In-cluster analysis has failed: %s", err)
			return
		}
		// reorganize messages to map
		index := map[status.Resource]diag.Messages{}
		for _, m := range res.Messages {

		i += cmsgAlignOf(int(h.Len))
	}
	return msgs, nil
}

// ParseOneSocketControlMessage parses a single socket control message from b, returning the message header,
// message data (a slice of b), and the remainder of b after that single message.
// When there are no remaining messages, len(remainder) == 0.
func ParseOneSocketControlMessage(b []byte) (hdr Cmsghdr, data []byte, remainder []byte, err error) {

    }

    def "starting message contains subsequent builds message given no unavailable daemons"() {
        given:
        def message = DaemonStartupMessage.generate(0, 0, 0)

        expect:
        message.contains(DaemonStartupMessage.STARTING_DAEMON_MESSAGE)
        message.contains(DaemonStartupMessage.SUBSEQUENT_BUILDS_WILL_BE_FASTER)
    }

	}

	var messages diag.Messages = make([]diag.Message, 0)
	if minor <= 21 {
		// ENHANCED_RESOURCE_SCOPING
		if err := checkPilot(cli, ctx.IstioNamespace(), &messages); err != nil {
			return nil, err
		}
	}
	if minor <= 20 {
		// VERIFY_CERTIFICATE_AT_CLIENT and ENABLE_AUTO_SNI
		if err := checkDestinationRuleTLS(cli, &messages); err != nil {
			return nil, err
		}