throw new SMBProtocolDecodingException("Invalid negotiate context count: " + negotiateContextCount + " (must be 0-100)");
        }

        bufferIndex += 4;

        // Validate sufficient buffer space for server GUID and capabilities
        if (buffer.length < bufferIndex + 16 + 4 + 4 + 4 + 4) {
            throw new SMBProtocolDecodingException("Buffer too small for server GUID and capabilities section");

        assertTrue(seq3 > seq2);
    }

    @Test
    void testHeartbeatUpdate() throws InterruptedException {
        long initialTime = registration.getLastHeartbeat();

        Thread.sleep(50); // Ensure sufficient time difference
        registration.updateHeartbeat();

        // After update, should not be expired with long timeout
        assertFalse(registration.isExpired(60000));

        assertEquals((byte) 0x00, bufferData[startIndex + alignmentBytes + 1], "Most significant byte should be second");
    }

    /**
     * When given a buffer with sufficient length, decode performs
     * the inverse of encode.
     */
    @Test
    void decodeFromEncodedBuffer() throws NdrException {
        NdrShort ns = new NdrShort(123); // masked value 123 (already fits in 8 bits)

        // Verify FID is written correctly (little-endian)
        int writtenFid = SMBUtil.readInt2(dst, 2);
        assertEquals(TEST_FID, writtenFid);
    }

    @Test
    @DisplayName("Test writeDataWireFormat with sufficient buffer")
    void testWriteDataWireFormatSufficientBuffer() {
        // Arrange
        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, TEST_FID, TEST_DATA, TEST_OFFSET, TEST_LENGTH);

      } else {
        utf8Length += encodedLengthGeneral(sequence, i);
        break;
      }
    }

    if (utf8Length < utf16Length) {
      // Necessary and sufficient condition for overflow because of maximum 3x expansion
      throw new IllegalArgumentException(
          "UTF-8 length does not fit in int: " + (utf8Length + (1L << 32)));
    }
    return utf8Length;
  }

1. The id_token is an identifier that is hard to guess. For example, a randomly generated string of sufficient length, that the server handling the protected resource can use to lookup the associated authorization information.

 *
 * We strongly suggest that you create an explicit {@link jcifs.context.CIFSContextWrapper}
 * with your desired config. It's base implementation {@link jcifs.context.BaseContext}
 * should be sufficient for most needs.
 *
 * If you want to retain the classic singleton behavior you can use
 * {@link jcifs.context.SingletonContext#getInstance()}
 * witch is initialized using system properties.
 *
 */

  scheme: http
  static_configs:
  - targets: ['localhost:9000']
```

#### 3.2 Public Prometheus config

If Prometheus endpoint authentication type is set to `public`. Following prometheus config is sufficient to start scraping metrics data from MinIO.
This can be collected from any server once per collection.

##### Cluster

```yaml
scrape_configs:
- job_name: minio-job

    }

    /**
     * Creates a basic negotiate response buffer with minimum valid structure.
     */
    private byte[] createBasicNegotiateResponseBuffer() {
        byte[] buffer = new byte[300]; // Sufficient size for basic structure + offsets

        // Structure size (65)
        SMBUtil.writeInt2(65, buffer, 0);

        // Security mode

    .getResponse();
```

## Troubleshooting

### Common Issues

**Index Creation Fails**
- Verify OpenSearch cluster is accessible
- Check index permissions and mappings
- Ensure sufficient cluster resources

**Suggestions Not Appearing**
- Confirm documents are indexed: `suggester.refresh()`
- Check query formatting and filters
- Verify analyzer configurations

**Performance Issues**