printerShare.type = 1;
        printerShare.remark = "Printer share";

        // Type 3 (named pipe) -> TYPE_NAMED_PIPE (16)
        srvsvc.ShareInfo1 pipeShare = new srvsvc.ShareInfo1();
        pipeShare.netname = "PipeShare";
        pipeShare.type = 3;
        pipeShare.remark = "Named pipe";

        // Create ShareInfoCtr1 with different share types

    }

    /**
     * Tests that the getter for the underlying pipe resource returns the correct instance.
     */
    @Test
    public void testGetPipe() {
        assertEquals(mockPipeResource, smbPipeHandle.getPipe(), "getPipe() should return the underlying pipe resource.");
    }

    /**
     * Tests that the getter for the input stream returns the correct stream.

        void testIsForceUnicodeMultipleCalls() {
            for (int i = 0; i < 5; i++) {
                assertTrue(response.isForceUnicode());
            }
        }
    }

    @Nested
    @DisplayName("Wire Format Write Tests")
    class WireFormatWriteTests {

        @Test
        @DisplayName("Should return 0 for writeSetupWireFormat")
        void testWriteSetupWireFormat() {
            byte[] dst = new byte[100];

     *
     * @param dst the destination buffer
     * @param dstIndex the starting offset in the buffer
     * @return the number of bytes written
     */
    protected abstract int writeParameterWordsWireFormat(byte[] dst, int dstIndex);

    /**
     * Writes the data bytes portion of the SMB message to the wire format.
     *

        assertNotNull(resp);
        assertTrue(resp instanceof ServerMessageBlock2Response);
        assertTrue(resp instanceof ServerMessageBlock2);
    }

    @Test
    @DisplayName("Should write empty bytes to wire format")
    void testWriteBytesWireFormat() {
        // Given
        byte[] buffer = new byte[256];
        int offset = 10;

        // When
        int bytesWritten = response.writeBytesWireFormat(buffer, offset);

        // Only compare the first 6 bytes that were actually written
        byte[] actualWritten = new byte[6];
        System.arraycopy(buffer, 0, actualWritten, 0, 6);
        assertArrayEquals(expected, actualWritten, "wire format should match expectation");
    }

    static Stream<Arguments> validParams() {
        // fid 0x1234, lastWriteTime 0 -> UTime all 0xFF

            } catch (final SmbException se) {
                fp = 0L;
            }
        }
        if (file instanceof SmbNamedPipe && file.unc.startsWith("\\pipe\\")) {
            file.unc = file.unc.substring(5);
            file.send(new TransWaitNamedPipe("\\pipe" + file.unc), new TransWaitNamedPipeResponse());
        }
        file.open(openFlags, access | SmbConstants.FILE_WRITE_DATA, SmbFile.ATTR_NORMAL, 0);

        }
    }

    @BeforeEach
    void setUp() {
        transaction = new TestSmbComTransaction();
        transaction.command = ServerMessageBlock.SMB_COM_TRANSACTION;
        transaction.name = "\\PIPE\\test";
        transaction.txn_buf = new byte[1024];
        transaction.maxBufferSize = 1024;
    }

    @Test
    @DisplayName("Test reset() method resets transaction state")
    void testReset() {

            // Test PIPE share type
            setPrivateField(response, "shareType", Smb2TreeConnectResponse.SMB2_SHARE_TYPE_PIPE);
            assertEquals(Smb2TreeConnectResponse.SMB2_SHARE_TYPE_PIPE, response.getShareType(), "Should handle PIPE share type");

            // Test PRINT share type

        }
        return buffer[bufferIndex] & 0xFF;
    }

    int type, length;

    /**
     * Writes the packet to the specified byte array in wire format.
     *
     * @param dst the destination byte array to write to
     * @param dstIndex the starting index in the destination array
     * @return written bytes
     */