assertEquals(0, (dst[5] << 8) | (dst[4] & 0xFF));
    }

    @Test
    void testWriteDataWireFormat() {
        // Given
        // writeInt8 writes 8 bytes but needs to access dst[dstIndex+7]
        // Total bytes written: 8+8+8+8+2+6=40
        // But writeInt8 at position 34 needs to access position 34+7=41
        // So we need at least 42 bytes in the array
        byte[] dst = new byte[42];

            byte[] buffer = new byte[8];
            byte[] original = buffer.clone();

            // Act
            int written = resp.writeBytesWireFormat(buffer, index);

            // Assert
            assertEquals(0, written, "Should report 0 bytes written");
            assertArrayEquals(original, buffer, "Buffer must remain unchanged");
        }

        @Test

		// from subsequent blocks.
		offset = 0

		// We have written all the blocks, write the last remaining block.
		if write < int64(len(block)) {
			n, err := dst.Write(block[:write])
			if err != nil {
				return 0, err
			}
			totalWritten += int64(n)
			break
		}

		// Copy the block.
		n, err := dst.Write(block)
		if err != nil {
			return 0, err
		}

		// Decrement output size.

        int result = smbCom.writeParameterWordsWireFormat(dst, 0);
        assertEquals(0, result);
    }

    @Test
    void testWriteBytesWireFormat() {
        // Test the byte format written by the class
        String directoryName = "\testDir";
        SmbComCreateDirectory smbCom = new SmbComCreateDirectory(mockConfig, directoryName);

        // Execute the method
        int bytesWritten = transaction.writeParameterWordsWireFormat(dst, 0);

        // Verify the bytes written
        assertTrue(bytesWritten > 0);

        // Verify max setup count is written at position 0
        assertEquals(2, dst[0]);

        // Verify reserved bytes
        assertEquals(0, dst[1]);
        assertEquals(0, dst[2]);

	// and don't process the If-Modified-Since header.
	if objInfo.ModTime.IsZero() || objInfo.ModTime.Equal(time.Unix(0, 0)) {
		return false
	}

	// Headers to be set of object content is not going to be written to the client.
	writeHeaders := func() {
		// set common headers
		setCommonHeaders(w)

		// set object-related metadata headers
		w.Header().Set(xhttp.LastModified, objInfo.ModTime.UTC().Format(http.TimeFormat))

        request.setNotifyFlags(0x0001);
        request.setCompletionFilter(0x00000FFF);

        // When
        byte[] buffer = new byte[512];
        int written = request.writeBytesWireFormat(buffer, 0);

        // Then
        assertEquals(32, written);

        // Verify complete structure
        assertEquals(32, SMBUtil.readInt2(buffer, 0)); // StructureSize

        System.arraycopy(buffer, 20, nameBytes, 0, nameLength);
        String decodedName = new String(nameBytes, StandardCharsets.UTF_16LE);
        assertEquals(fileName, decodedName);

        // Verify bytes written
        assertEquals(20 + nameLength, bytesWritten);
    }

    @Test
    @DisplayName("Test encode with replaceIfExists false")
    void testEncodeWithReplaceIfExistsFalse() {

	"path"
	"slices"
	"strings"
	"time"
)

// Writer provides sequential writing of a tar archive.
// [Writer.WriteHeader] begins a new file with the provided [Header],
// and then Writer can be treated as an io.Writer to supply that file's data.
type Writer struct {
	w    io.Writer
	pad  int64      // Amount of padding to write after current file entry
	curr fileWriter // Writer for current file entry

        assertEquals(4, bytesWritten);

        // Verify structure size (4) is written at offset
        assertEquals(4, SMBUtil.readInt2(buffer, offset));

        // Verify reserved field (0) is written at offset + 2
        assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));
    }

    @Test
    @DisplayName("Should write exact wire format structure")
    void testWriteBytesWireFormatStructure() {
        // Given