cp >>>= 2;
      dest[2] = upperHexDigits[cp & 0xF];
      cp >>>= 4;
      dest[1] = upperHexDigits[0xC | cp];
      return dest;
    } else if (cp <= 0xffff) {
      // Three byte UTF-8 characters [cp >= 0x800 && cp <= 0xffff]
      // Start with "%E-%--%--" and fill in the blanks
      char[] dest = new char[9];
      dest[0] = '%';
      dest[1] = 'E';
      dest[3] = '%';
      dest[6] = '%';

        // Assert
        assertNotNull(trans);
        assertEquals(0, trans.maxParameterCount);
        assertEquals(0xFFFF, trans.maxDataCount);
        assertEquals(0x00, trans.maxSetupCount);
        assertEquals(2, trans.setupCount);
        assertEquals("\\PIPE\\", trans.name);
    }

    @Test

    @Test
    void testDecNdrStringInvalidConformance() {
        // Simulate a string with invalid size
        ndrBuffer.setIndex(0);
        Encdec.enc_uint32le(0xFFFF + 1, buffer, 0); // len = 0xFFFF + 1
        Encdec.enc_uint32le(0, buffer, 4);
        Encdec.enc_uint32le(0xFFFF + 1, buffer, 8);

        ndrBuffer.setIndex(0);
        NdrException thrown = assertThrows(NdrException.class, () -> {
            ndrBuffer.dec_ndr_string();

        assertEquals(30000, SmbConstants.DEFAULT_RESPONSE_TIMEOUT);
        assertEquals(35000, SmbConstants.DEFAULT_SO_TIMEOUT);
        assertEquals(0xFFFF, SmbConstants.DEFAULT_RCV_BUF_SIZE);
        assertEquals(0xFFFF, SmbConstants.DEFAULT_SND_BUF_SIZE);
        assertEquals(250, SmbConstants.DEFAULT_SSN_LIMIT);
        assertEquals(35000, SmbConstants.DEFAULT_CONN_TIMEOUT);

                final int _ss = _src.dec_ndr_long();
                final int _si = _src.index;
                _src.advance(4 * _ss);

                if (s == null) {
                    if (_ss < 0 || _ss > 0xFFFF) {
                        throw new NdrException(NdrException.INVALID_CONFORMANCE);
                    }
                    s = new DfsInfo1[_ss];
                }
                _src = _src.derive(_si);

    }

    @Test
    @DisplayName("Test default buffer size constant")
    void testBufferSizeConstant() {
        assertEquals(0xFFFF, SmbComTransaction.TRANSACTION_BUF_SIZE, "TRANSACTION_BUF_SIZE should be 0xFFFF");
    }

    @Test
    @DisplayName("Test transaction subcommand constants")
    void testSubcommandConstants() {
        // Test Trans2 subcommands

        assertEquals(0, reserved);
    }

    @DisplayName("Test writeParametersWireFormat with different FIDs")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 0xFFFF, 0x8000, 0x7FFF })
    void testWriteParametersWireFormatWithDifferentFids(int fid) {
        when(mockFileInfo.getFileInformationLevel()).thenReturn((byte) FileInformation.FILE_BASIC_INFO);

        // Assert
        assertNotNull(transPeekNamedPipe);
        assertNull(transPeekNamedPipe.name);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, -1, Integer.MAX_VALUE, Integer.MIN_VALUE, 0xFFFF })
    @DisplayName("Constructor should handle various FID values")
    void testConstructorWithVariousFids(int fid) {
        // Act
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, fid);

        assertEquals(0xFFFFFFFF, transCallNamedPipe.timeout);
        assertEquals(0, transCallNamedPipe.maxParameterCount);
        assertEquals(0xFFFF, transCallNamedPipe.maxDataCount);
        assertEquals((byte) 0x00, transCallNamedPipe.maxSetupCount);
        assertEquals(2, transCallNamedPipe.setupCount);
    }

    @Test

    void testReadBytesWireFormatNegativeStructureSize() {
        byte[] buffer = new byte[1024];
        int bufferIndex = 0;

        // Set structure size to -1 (0xFFFF when read as unsigned)
        SMBUtil.writeInt2(0xFFFF, buffer, bufferIndex);

        SMBProtocolDecodingException exception =
                assertThrows(SMBProtocolDecodingException.class, () -> response.readBytesWireFormat(buffer, bufferIndex),