@Test
    @DisplayName("reauthenticate throws CIFSException when underlying call fails")
    void reauthenticate_throws() throws CIFSException {
        doThrow(new CIFSException("reauth failed")).when(session).reauthenticate();
        CIFSException ex = assertThrows(CIFSException.class, () -> session.reauthenticate());
        assertTrue(ex.getMessage().contains("failed"));

                    request.setDigest(getDigest());
                }

                if (request instanceof RequestWithPath rpath) {
                    ((RequestWithPath) request).setFullUNCPath(getTargetDomain(), getTargetHost(), rpath.getFullUNCPath());
                }

                try {
                    if (log.isTraceEnabled()) {
                        log.trace("Request " + request);

    }

    @Test
    @DisplayName("Should derive unique keys for different preauth values")
    void testDeriveKeys_UniquePreauthValues() {
        // Given
        byte[] preauth1 = new byte[64];
        byte[] preauth2 = new byte[64];
        new SecureRandom().nextBytes(preauth1);
        new SecureRandom().nextBytes(preauth2);
        int dialect = Smb2Constants.SMB2_DIALECT_0311;

        // When

		"Count of offline nodes in the cluster")
	healthNodesOnlineCountMD = NewGaugeMD(healthNodesOnlineCount,
		"Count of online nodes in the cluster")
)

// loadClusterHealthNodeMetrics - `MetricsLoaderFn` for cluster health node
// metrics.
func loadClusterHealthNodeMetrics(ctx context.Context, m MetricValues,
	c *metricsCache,
) error {
	nodesUpDown, _ := c.nodesUpDown.Get()

	m.Set(healthNodesOfflineCount, float64(nodesUpDown.Offline))

            if (enforceIntegrity) {
                throw new CIFSException("No preauth integrity context found for session: " + sessionId);
            }
            log.warn("No preauth integrity context for session {}, skipping update", sessionId);
            return;
        }

        if (!context.isValid()) {
            throw new CIFSException("Preauth integrity context is invalid for session: " + sessionId);
        }

        void testDifferentContextTypes() {
            PreauthIntegrityNegotiateContext preauth = new PreauthIntegrityNegotiateContext();
            EncryptionNegotiateContext encryption = new EncryptionNegotiateContext();

            assertNotEquals(preauth.getContextType(), encryption.getContextType());
            assertEquals(0x1, preauth.getContextType());
            assertEquals(0x2, encryption.getContextType());
        }

    private int[] hashAlgos;
    private byte[] salt;

    /**
     * Constructs a preauth integrity negotiate context with the specified parameters.
     *
     * @param config the SMB configuration
     * @param hashAlgos the supported hash algorithms
     * @param salt the salt value for preauth integrity
     */

        assertNotNull(enc);
        assertTrue(enc instanceof EncryptionNegotiateContext);

        // Test preauth context
        NegotiateContextResponse preauth = Smb2NegotiateResponse.createContext(PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE);
        assertNotNull(preauth);
        assertTrue(preauth instanceof PreauthIntegrityNegotiateContext);

        // Test unknown context

          MYSQL_RANDOM_ROOT_PASSWORD: "yes"
        ports:
          - 9910:3306
        options: >-
          --health-cmd "mysqladmin ping -ugorm -pgorm"
          --health-interval 10s
          --health-start-period 10s
          --health-timeout 5s
          --health-retries 10

    steps:
    - name: Set up Go 1.x
      uses: actions/setup-go@v4
      with:
        go-version: ${{ matrix.go }}

## Liveness probe

This probe always responds with '200 OK'. Only fails if 'etcd' is configured and unreachable. When liveness probe fails, Kubernetes like platforms restart the container.

```
livenessProbe:
  httpGet:
    path: /minio/health/live
    port: 9000
    scheme: HTTP
  initialDelaySeconds: 120