t.Fatalf("unexpected error: %v", err)
	}
	val := maskString("hello")
	ps.Publish(val)

	msg1 := <-ch1
	msg2 := <-ch2
	if msg1 != val && msg2 != val {
		t.Fatalf("expected both subscribers to have%s , found %s and  %s", val, msg1, msg2)
	}

	select {
	case msg := <-ch3:
		t.Fatalf("unexpected msg, f got %s", msg)
	default:
	}

                final Type3Message msg3 =
                        new Type3Message(msg2, auth.getPassword(), auth.getDomain(), auth.getUsername(), workstation, ntlmsspFlags);
                token = msg3.toByteArray();

                if (LogStream.level >= 4) {
                    log.println(msg3);
                    if (LogStream.level >= 6) {

        ComponentUtil.getLogNotificationHelper()
                .offer(new LogNotificationEvent(System.currentTimeMillis(), "ERROR", "org.test", "msg1", null));
        ComponentUtil.getLogNotificationHelper()
                .offer(new LogNotificationEvent(System.currentTimeMillis(), "WARN", "org.test", "msg2", null));

        // expired() will drain buffer then fail on OpenSearch (not available) but should not throw

        assertEquals("DCERPC_FAULT_CANT_PERFORM", msg3);

        String msg4 = DcerpcException.getMessageByDcerpcError(DcerpcError.DCERPC_FAULT_NDR);
        assertEquals("DCERPC_FAULT_NDR", msg4);

        String msg5 = DcerpcException.getMessageByDcerpcError(DcerpcError.DCERPC_FAULT_INVALID_TAG);
        assertEquals("DCERPC_FAULT_INVALID_TAG", msg5);

}

func (muxConnectError) Op() Op {
	return OpMuxConnectError
}

type pongMsg struct {
	NotFound bool      `msg:"nf"`
	Err      *string   `msg:"e,allownil"`
	T        time.Time `msg:"t"`
}

func (pongMsg) Op() Op {
	return OpPong
}

type pingMsg struct {
	T time.Time `msg:"t"`
}

func (pingMsg) Op() Op {
	return OpPing

	if u.detail == "" {
		if u.msg != "" {
			return u.msg
		}
		return "<nil>"
	}
	return u.detail
}

// Msg - Replace the current error's message
func (u Err) Msg(m string) Err {
	e := u.Clone()
	e.msg = m
	return e
}

// Msgf - Replace the current error's message
func (u Err) Msgf(m string, args ...any) Err {
	e := u.Clone()
	if len(args) == 0 {
		e.msg = m
	} else {
		e.msg = fmt.Sprintf(m, args...)
	}

Daryl White <******@****.***> 1755022836 -0400

		return tls.Certificate{}, ErrTLSReadError(nil).Msgf("Unable to read the public key: %s", err)
	}
	keyPEMBlock, err := os.ReadFile(keyFile)
	if err != nil {
		return tls.Certificate{}, ErrTLSReadError(nil).Msgf("Unable to read the private key: %s", err)
	}
	key, rest := pem.Decode(keyPEMBlock)
	if len(rest) > 0 {
		return tls.Certificate{}, ErrTLSUnexpectedData(nil).Msgf("The private key contains additional data")
	}
	if key == nil {

	bucket       string     `msg:"b"`
	filter       string     `msg:"flt"`
	id           string     `msg:"id"`
	error        string     `msg:"err"`
	root         string     `msg:"root"`
	fileNotFound bool       `msg:"fnf"`
	status       scanStatus `msg:"stat"`
	recursive    bool       `msg:"rec"`
	dataVersion  uint8      `msg:"v"`
}

func (m *metacache) finished() bool {
	return !m.ended.IsZero()
}

	ETag       string            `json:"etag,omitempty" msg:"e"`
	Number     int               `json:"number" msg:"n"`
	Size       int64             `json:"size" msg:"s"`        // Size of the part on the disk.
	ActualSize int64             `json:"actualSize" msg:"as"` // Original size of the part without compression or encryption bytes.
	ModTime    time.Time         `json:"modTime" msg:"mt"`    // Date and time at which the part was uploaded.