byte[] buffer = new byte[1024];
        request.writeBytesWireFormat(buffer, Smb2Constants.SMB2_HEADER_LENGTH);

        // FileId is at offset 8 in the request structure
        for (int i = 0; i < 16; i++) {
            assertEquals(fileId[i], buffer[Smb2Constants.SMB2_HEADER_LENGTH + 8 + i]);
        }
    }

    @Test
    @DisplayName("Test setFileInformationClass method")

 */
package jcifs.internal.smb2.ioctl;

import jcifs.Decodable;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 SRV_REQUEST_RESUME_KEY response data structure. This structure contains a resume key
 * that can be used for server-side copy operations.
 *
 * @author mbechler
 *
 */
public class SrvRequestResumeKeyResponse implements Decodable {

    /**

            assertTrue(bytesRead > 0);
            // readDataWireFormat returns bytes consumed from header, not full buffer
            assertEquals(28, bytesRead); // Header + one referral structure
            assertNotNull(response.getDfsResponse());
        }

        @Test
        @DisplayName("Should handle readDataWireFormat with offset")
        void testReadDataWireFormatWithOffset() {

        @Test
        @DisplayName("Should decode error response with correct structure size")
        void testReadErrorResponseValid() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[256];
            int bufferIndex = 0;

            // Write error response structure
            SMBUtil.writeInt2(9, buffer, bufferIndex); // structure size
            buffer[bufferIndex + 2] = 2; // error context count

import java.util.Map.Entry;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * A map-like data structure that wraps a backing map and caches values while iterating through
 * {@link #unmodifiableKeySet()}. By design, the cache is cleared when this structure is mutated. If
 * this structure is never mutated, it provides a thread-safe view of the backing map.
 *

### Project file structure { #project-file-structure }

Let's say your project file structure looks like this:

```
.
├── app
│   ├── __init__.py
│   ├── main.py
```

Now create a directory to store those static files.

Your new file structure could look like this:

```
.
├── app
│   ├── __init__.py
│   ├── main.py

        }

        @Test
        @DisplayName("Should throw exception for invalid structure size")
        void testReadBytesWireFormatWithInvalidStructureSize() {
            // Given
            byte[] buffer = new byte[60];
            SMBUtil.writeInt2(59, buffer, 0); // Invalid structure size (should be 60)

            // When & Then
            assertThrows(SMBProtocolDecodingException.class, () -> {

import jcifs.internal.AllocInfo;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;

/**
 * Represents the FILE_FS_FULL_SIZE_INFORMATION structure used to query comprehensive file system size information.
 * This structure provides complete allocation details including total allocation units, caller-available free units,
 * actual free allocation units, sectors per allocation unit, and bytes per sector.
 */

   *
   * <p>You may also consider the equivalent {@code
   * MultimapBuilder.hashKeys().arrayListValues().build()}, which provides more control over the
   * underlying data structure.
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      ArrayListMultimap<K, V> create() {
    return new ArrayListMultimap<>();
  }

  /**

 */
package jcifs.internal.smb2.ioctl;

import jcifs.Encodable;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 SRV_COPYCHUNK data structure. This structure represents a single chunk specification
 * for server-side copy operations.
 *
 * @author mbechler
 *
 */
public class SrvCopychunk implements Encodable {

    private final long sourceOffset;