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

        // 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);

        }
    }

    @Test
    void testLargeBatchParameters() {
        // Test with maximum allowed values
        int maxSid = 0xFFFF;
        int maxResumeKey = 0x7FFFFFFF;
        int maxBatchCount = 65535;
        int maxBatchSize = 65535;

        trans2FindNext2 = new Trans2FindNext2(config, maxSid, maxResumeKey, TEST_FILENAME, maxBatchCount, maxBatchSize);

        // 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

     */
    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))) {

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

        Hexdump.toHexChars(0, dst1, 0, 4);
        assertEquals("0000", new String(dst1));

        // Test with all F's
        char[] dst2 = new char[8];
        Hexdump.toHexChars(0xFFFFFFFF, dst2, 0, 8);
        assertEquals("FFFFFFFF", new String(dst2));

        // Test partial buffer update
        char[] dst3 = new char[6];
        java.util.Arrays.fill(dst3, 'Z');

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

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

fields. The 64 bit fields will always contain the correct value and
for normal archives both fields will be the same. For files requiring
the ZIP64 format the 32 bit fields will be 0xffffffff and the 64 bit
fields must be used instead.

[ZIP specification]: https://support.pkware.com/pkzip/appnote
*/
package zip

import (
	"io/fs"
	"path"
	"time"
)

// Compression methods.

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