len += 2;
                    if (len > maxLen) {
                        if (LogStream.level > 0) {
                            Hexdump.hexdump(System.err, src, srcIndex, maxLen < 128 ? maxLen + 8 : 128);
                        }
                        throw new RuntimeException("zero termination not found");
                    }
                }

        }

        @Test
        @DisplayName("Should accept valid parameters in sign method")
        void testSignValidParameters() {
            byte[] data = new byte[128];
            // Should not throw
            digest.sign(data, 0, 128, request, response);

            // Verify signature was added
            byte[] signature = Arrays.copyOfRange(data, SIGNATURE_OFFSET, SIGNATURE_OFFSET + SIGNATURE_LENGTH);

        void testPowerOfTwoValues() {
            long powerOfTwoOffset = 1L << 32; // 2^32
            long powerOfTwoLength = 1L << 16; // 2^16
            int powerOfTwoFlags = 1 << 8; // 2^8

            lock = new Smb2Lock(powerOfTwoOffset, powerOfTwoLength, powerOfTwoFlags);
            lock.encode(buffer, 0);

            assertEquals(powerOfTwoOffset, SMBUtil.readInt8(buffer, 0));

        Method readStringMethod = getReadStringMethod();
        String result = (String) readStringMethod.invoke(response, buffer, 0, 128, false);

        assertEquals(testString, result);
    }

    @ParameterizedTest
    @DisplayName("Test readDataWireFormat with various share types")

      assertThat(expected)
          .hasMessageThat()
          .isEqualTo("Unpaired surrogate at index " + invalidCodePointIndex);
    }
  }

  // 128 - [chars 0x0000 to 0x007f]
  private static final long ONE_BYTE_ROUNDTRIPPABLE_CHARACTERS = 0x007f - 0x0000 + 1;

  // 128
  private static final long EXPECTED_ONE_BYTE_ROUNDTRIPPABLE_COUNT =
      ONE_BYTE_ROUNDTRIPPABLE_CHARACTERS;

  // 1920 [chars 0x0080 to 0x07FF]

        Method readStringMethod = getReadStringMethod();
        String result = (String) readStringMethod.invoke(response, buffer, 0, 128, false);

        assertEquals(testString, result);
    }

    @Test
    @DisplayName("Test readDataWireFormat with maximum length server name")
    void testReadDataWireFormatMaxLengthServerName() throws Exception {
        setConverter(response, 0);

- **SMB 2.0.2**: Windows Vista+ (0x0202)
- **SMB 2.1**: Windows 7/Server 2008R2 (0x0210)
- **SMB 3.0**: Windows 8/Server 2012 (0x0300) - AES-128-CCM encryption
- **SMB 3.0.2**: Windows 8.1/Server 2012R2 (0x0302) - Enhanced encryption
- **SMB 3.1.1**: Windows 10/Server 2016+ (0x0311) - AES-128-GCM + Pre-Auth Integrity

**Protocol Selection:**
- Default Range: SMB1 to SMB 3.1.1

            assertEquals(0, new NdrShort(256).value); // 256 & 0xFF = 0
            assertEquals(255, new NdrShort(-1).value); // -1 & 0xFF = 255
            assertEquals(128, new NdrShort(-128).value); // -128 & 0xFF = 128
        }

        @Test
        @DisplayName("Should maintain value consistency after multiple constructions")
        void testValueConsistency() {
            // Given: Same input value

    assertThat(max((byte) 0, (byte) -128, (byte) -1, (byte) 127, (byte) 1)).isEqualTo((byte) 127);
  }

  public void testMin_noArgs() {
    assertThrows(IllegalArgumentException.class, () -> min());
  }

  public void testMin() {
    assertThat(min(LEAST)).isEqualTo(LEAST);
    assertThat(min(GREATEST)).isEqualTo(GREATEST);
    assertThat(min((byte) 0, (byte) -128, (byte) -1, (byte) 127, (byte) 1)).isEqualTo((byte) -128);

    /**
     * Context type
     */
    public static final int NEGO_CTX_ENC_TYPE = 0x2;

    /**
     * AES 128 CCM
     */
    public static final int CIPHER_AES128_CCM = 0x1;

    /**
     * AES 128 GCM
     */
    public static final int CIPHER_AES128_GCM = 0x2;

    /**
     * AES 256 CCM
     */
    public static final int CIPHER_AES256_CCM = 0x3;