// Set empty target name buffer
            Type2Message.writeUShort(truncatedMessage, 12, 0); // length
            Type2Message.writeUShort(truncatedMessage, 14, 0); // max length
            Type2Message.writeULong(truncatedMessage, 16, 48); // offset (past the end)
            // Set flags
            Type2Message.writeULong(truncatedMessage, 20, Type2Message.NTLMSSP_NEGOTIATE_UNICODE);

        assertEquals(DialectVersion.SMB202, config.getMinimumVersion());
        assertEquals(DialectVersion.SMB311, config.getMaximumVersion());
    }

    @Test
    @DisplayName("Test initProtocolVersions with min >= max")
    void testInitProtocolVersionsWithMinGreaterThanMax() {
        config.initProtocolVersions("SMB311", "SMB202");

        assertEquals(DialectVersion.SMB311, config.getMinimumVersion());

        int randomInt = random.nextInt();
        mmHeap.offer(randomInt);
        insertIntoReplica(replica, randomInt);
        currentHeapSize++;
      } else {
        /* remove either min or max */
        if (random.nextBoolean()) {
          removeMinFromReplica(replica, mmHeap.poll());
        } else {
          removeMaxFromReplica(replica, mmHeap.pollLast());
        }

///

FastAPI will now:

* **Validate** the data making sure that the max length is 50 characters
* Show a **clear error** for the client when the data is not valid
* **Document** the parameter in the OpenAPI schema *path operation* (so it will show up in the **automatic docs UI**)

   * @param start the starting bytes encoded as a long as big-endian
   * @param lim the limit of bytes to process encoded as a long as big-endian, or -1 to mean the max
   *     limit for numBytes
   */
  @GwtIncompatible // java.nio.charset.Charset
  private static void testBytes(int numBytes, long expectedCount, long start, long lim) {
    byte[] bytes = new byte[numBytes];

    // Should we pepper more of these calls throughout the above? Where?
    CacheTesting.checkValidState(cache);
  }

  /**
   * Tests that when a single entry exceeds the segment's max weight, the new entry is immediately
   * evicted and nothing else.
   */
  public void testEviction_maxWeight_entryTooBig() {
    CountingRemovalListener<Integer, Integer> removalListener = countingRemovalListener();

        assertEquals(0, Encdec.dec_uint32le(buffer, 4)); // Offset
        assertEquals(testString.length() + 1, Encdec.dec_uint32le(buffer, 8)); // Max count

        ndrBuffer.setIndex(0);
        String decodedString = ndrBuffer.dec_ndr_string();
        assertEquals(testString, decodedString);
        assertEquals(expectedLength, ndrBuffer.getIndex());

				avgQueueCount.Value = qt.Avg.Count
				maxQueueBytes.Value = qt.Max.Bytes
				maxQueueCount.Value = qt.Max.Count
			}
			activeWorkersCount.Value = float64(qs.ActiveWorkers.Curr)
			avgActiveWorkersCount.Value = float64(qs.ActiveWorkers.Avg)
			maxActiveWorkersCount.Value = float64(qs.ActiveWorkers.Max)

			if len(qs.XferStats) > 0 {
				tots := qs.XferStats[Total]

        assertEquals((byte) 0xFF, dst[1]);
        assertEquals((byte) 0xFF, dst[2]);
        assertEquals((byte) 0xFF, dst[3]);
    }

    @Test
    @DisplayName("Test writeUTime with max time")
    void testWriteUTimeWithMaxTime() {
        byte[] dst = new byte[4];

        SMB1SigningDigest.writeUTime(mockConfig, 0xFFFFFFFFFFFFFFFFL, dst, 0);

        assertEquals((byte) 0xFF, dst[0]);

        assertEquals(132514080000000000L, serverData.serverTime);

        // Test with negative value
        serverData.serverTime = -1L;
        assertEquals(-1L, serverData.serverTime);

        // Test with max value
        serverData.serverTime = Long.MAX_VALUE;
        assertEquals(Long.MAX_VALUE, serverData.serverTime);

        // Test with min value
        serverData.serverTime = Long.MIN_VALUE;