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

        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;

        @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;

        // Prepare test data with maximum values
        byte[] buffer = new byte[50];
        int bufferIndex = 0;

        // Set maximum values
        int testCapabilities = 0xFFFFFFFF;
        byte[] testGuid = new byte[16];
        Arrays.fill(testGuid, (byte) 0xFF);
        int testSecurityMode = 0xFFFF;
        int testDialect = 0xFFFF;

        // Write to buffer

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);

        // Write the special "never" FILETIME value
        writeLittleEndianInt(dos, 0xffffffff);
        writeLittleEndianInt(dos, 0x7fffffff);

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        PacDataInputStream pacStream = new PacDataInputStream(bais);

     */
    public static void writeUTime(final Configuration cfg, long t, final byte[] dst, final int dstIndex) {
        if (t == 0L || t == 0xFFFFFFFFFFFFFFFFL) {
            SMBUtil.writeInt4(0xFFFFFFFF, dst, dstIndex);
            return;
        }

        if (cfg.getLocalTimezone().inDaylightTime(new Date())) {
            // in DST
            if (cfg.getLocalTimezone().inDaylightTime(new Date(t))) {

        // Assert
        assertNotNull(transPeekNamedPipe);
        assertEquals(TEST_PIPE_NAME, transPeekNamedPipe.name);
        assertEquals(0xFFFFFFFF, transPeekNamedPipe.timeout);
        assertEquals(6, transPeekNamedPipe.maxParameterCount);
        assertEquals(1, transPeekNamedPipe.maxDataCount);
        assertEquals((byte) 0x00, transPeekNamedPipe.maxSetupCount);

                        : targetName.toUpperCase().getBytes(getOEMEncoding());
                size += targetBytes.length;
            } else {
                flags &= 0xffffffff ^ NTLMSSP_REQUEST_TARGET;
            }
        }

        if (targetInformationBytes != null) {
            size += targetInformationBytes.length;
            flags |= NTLMSSP_NEGOTIATE_TARGET_INFO;

                            : targetName.toUpperCase().getBytes(getOEMEncoding());
                } else {
                    flags &= 0xffffffff ^ NTLMSSP_REQUEST_TARGET;
                }
            }
            if (targetInformation != null) {
                flags |= NTLMSSP_NEGOTIATE_TARGET_INFO;

        buffer[bufferIndex + 2] = (byte) 0xFF;

        // Set fields with negative values (should be treated as unsigned)
        SMBUtil.writeInt4(-1, buffer, bufferIndex + 3); // Should be read as 0xFFFFFFFF
        SMBUtil.writeInt4(-100, buffer, bufferIndex + 7);
        SMBUtil.writeInt4(-1000, buffer, bufferIndex + 11);
        SMBUtil.writeInt4(0, buffer, bufferIndex + 15);