private final int value;

  private UnsignedInteger(int value) {
    // GWT doesn't consistently overflow values to make them 32-bit, so we need to force it.
    this.value = value & 0xffffffff;
  }

  /**
   * Returns an {@code UnsignedInteger} corresponding to a given bit representation. The argument is
   * interpreted as an unsigned 32-bit value. Specifically, the sign bit of {@code bits} is

    @Test
    @DisplayName("Test encode with maximum capabilities value")
    void testEncodeWithMaxCapabilities() {
        ValidateNegotiateInfoRequest request =
                new ValidateNegotiateInfoRequest(0xFFFFFFFF, defaultClientGuid, DEFAULT_SECURITY_MODE, defaultDialects);

        byte[] buffer = new byte[request.size()];
        request.encode(buffer, 0);

        // Verify max capabilities value (comparing as unsigned long)

        case TIME_1904_SEC_32BE -> enc_uint32be((int) (date.getTime() / 1000L + SEC_BETWEEEN_1904_AND_1970 & 0xFFFFFFFF), dst, di);
        case TIME_1904_SEC_32LE -> enc_uint32le((int) (date.getTime() / 1000L + SEC_BETWEEEN_1904_AND_1970 & 0xFFFFFFFF), dst, di);
        case TIME_1601_NANOS_64BE -> {
            t = (date.getTime() + SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601) * 10000L;

      int count = 0;
      // originally was 2 * Math.log(...), making it try more times to avoid flakiness issues
      int maxCount = (int) (4 * Math.log(2 * keyBits * hashBits) + 1);
      while (same != 0xffffffff || diff != 0xffffffff) {
        int key1 = rand.nextInt();
        // flip input bit for key2
        int key2 = key1 ^ (1 << i);
        // get hashes
        int hash1 = function.hashInt(key1).asInt();

        assertEquals(0xFFFF, pdis.readUnsignedShort());
    }

    @Test
    public void testReadUnsignedInt() throws IOException {
        // Little-endian 0xFFFFFFFF -> 0xFF 0xFF 0xFF 0xFF
        byte[] data = new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };
        PacDataInputStream pdis = createInputStream(data);

        @DisplayName("toString() should handle maximum values correctly")
        void testToStringMaxValues() {
            // Arrange
            rpc.uuid_t rpcUuid = new rpc.uuid_t();
            rpcUuid.time_low = 0xFFFFFFFF;
            rpcUuid.time_mid = (short) 0xFFFF;
            rpcUuid.time_hi_and_version = (short) 0xFFFF;
            rpcUuid.clock_seq_hi_and_reserved = (byte) 0xFF;
            rpcUuid.clock_seq_low = (byte) 0xFF;

        @DisplayName("Should create lock with maximum values")
        void testConstructorWithMaxValues() {
            long maxOffset = Long.MAX_VALUE;
            long maxLength = Long.MAX_VALUE;
            int flags = 0xFFFFFFFF;

            lock = new Smb2Lock(maxOffset, maxLength, flags);

            assertNotNull(lock);
        }

        @Test
        @DisplayName("Should create lock with negative values")

        case TIME_1904_SEC_32BE -> enc_uint32be((int) (date.getTime() / 1000L + SEC_BETWEEEN_1904_AND_1970 & 0xFFFFFFFF), dst, di);
        case TIME_1904_SEC_32LE -> enc_uint32le((int) (date.getTime() / 1000L + SEC_BETWEEEN_1904_AND_1970 & 0xFFFFFFFF), dst, di);
        case TIME_1601_NANOS_64BE -> {
            t = (date.getTime() + MILLISECONDS_BETWEEN_1970_AND_1601) * 10000L;

                    buf[i + 3] = (byte) (fakeLen & 0xFF);
                    return buf;
                }, IllegalArgumentException.class),

                // Negative NAME_LEN (0xFFFFFFFF) causes StringIndexOutOfBoundsException
                Arguments.of("negative name length triggers SIOOBE", (java.util.function.Supplier<byte[]>) () -> {
                    byte[] tok = new byte[] { 0x04, 0x01 };

        assertTrue(str.endsWith("]"));
    }

    @ParameterizedTest
    @DisplayName("Test toString with various type values")
    @ValueSource(ints = { 0x00000000, 0x00000001, 0x00000003, 0x80000000, 0x80000001, 0xFFFFFFFF })
    void testToStringWithVariousTypes(int type) {
        SmbShareInfo info = new SmbShareInfo(TEST_NET_NAME, type, TEST_REMARK);
        String str = info.toString();

        // Verify type is displayed as hex