}

        @ParameterizedTest
        @DisplayName("Should encode consistently with various flag values")
        @ValueSource(ints = { 0, 1, 2, 4, 16, 0xFF, 0xFFFF, 0xFFFFFF, 0x7FFFFFFF, -1 })
        void testEncodingWithVariousFlags(int flags) {
            lock = new Smb2Lock(1024L, 2048L, flags);
            int encoded = lock.encode(buffer, 0);

            assertEquals(24, encoded);

      0x1ff8,
      0x7fffd8,
      0xfffffe2,
      0xfffffe3,
      0xfffffe4,
      0xfffffe5,
      0xfffffe6,
      0xfffffe7,
      0xfffffe8,
      0xffffea,
      0x3ffffffc,
      0xfffffe9,
      0xfffffea,
      0x3ffffffd,
      0xfffffeb,
      0xfffffec,
      0xfffffed,
      0xfffffee,
      0xfffffef,
      0xffffff0,
      0xffffff1,
      0xffffff2,
      0x3ffffffe,

            this.largeReadX = true;
            this.readSizeFile =
                    Math.min(th.getConfig().getReceiveBufferSize() - 70, th.areSignaturesActive() ? 0xFFFF - 70 : 0xFFFFFF - 70);
            log.debug("Enabling LARGE_READX with " + this.readSizeFile);
        } else {
            log.debug("LARGE_READX disabled");
            this.readSizeFile = this.readSize;
        }

            }

            // there seems to be a bug with some servers that causes corruption if using signatures + CAP_LARGE_WRITE
            if (th.hasCapability(SmbConstants.CAP_LARGE_WRITEX) && !th.areSignaturesActive()) {
                this.writeSize = Math.min(th.getConfig().getSendBufferSize() - 70, 0xFFFF - 70);
            }

            this.fp = 0L;

	AND	$0xff00ff, R2                       // AND	$16711935, R2                   // fb1f80d2fb1fa0f242001b8a
	AND	$0xff00ffff, R1                     // AND	$4278255615, R1                 // fbff9fd21be0bff221001b8a
	ANDS	$0xffff, R2                         // ANDS	$65535, R2                      // 423c40f2
	AND	$0x7fffffff, R3                     // AND	$2147483647, R3                 // 63784092

        // Little-endian 0xFFFF -> 0xFF 0xFF
        byte[] data = new byte[] { (byte) 0xFF, (byte) 0xFF, 0x00, 0x00 };
        PacDataInputStream pdis = createInputStream(data);
        assertEquals(0xFFFF, pdis.readUnsignedShort());
    }

    @Test
    public void testReadUnsignedInt() throws IOException {
        // Little-endian 0xFFFFFFFF -> 0xFF 0xFF 0xFF 0xFF

        return Stream.of(Arguments.of(0), Arguments.of(1), Arguments.of(255), Arguments.of(256), Arguments.of(65535), Arguments.of(65536),
                Arguments.of(0x7FFFFFFF), Arguments.of(0xFFFFFFFF));
    }

    @Test
    @DisplayName("readInt2 should correctly read 16-bit integer")
    void testReadInt2() {
        byte[] src = { (byte) 0x12, (byte) 0x34, (byte) 0x56 };

     */
    @Test
    void testGetMessageByDcerpcError_smallerThanAny() {
        int unknownCode = -1;
        String message = DcerpcException.getMessageByDcerpcError(unknownCode);
        assertEquals("0xFFFFFFFF", message, "Should return hex string for code smaller than any known.");
    }

    /**
     * Test getMessageByDcerpcError() with an error code larger than any known.

                Arguments.of(0x12345678, new byte[] { 0x78, 0x56, 0x34, 0x12 }),
                Arguments.of(0xFFFFFFFF, new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }),
                Arguments.of(0x7FFFFFFF, new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0x7F }));
    }

    @ParameterizedTest
    @MethodSource("int32Provider")

                pipeIn = new TransactNamedPipeInputStream(this);
            } else {
                pipeIn = new SmbFileInputStream(this, pipeType & 0xFFFF00FF | SmbFile.O_EXCL);
            }
        }
        return pipeIn;
    }

    /**
     * Return the <code>OutputStream</code> used to write