}
        this.fileId = Arrays.copyOf(fileId, 16);
    }

    @Override
    public byte[] getName() {
        return CONTEXT_NAME_BYTES;
    }

    /**
     * Get the file ID
     * @return the 16-byte file ID
     */
    public byte[] getFileId() {
        return Arrays.copyOf(fileId, 16);
    }

    @Override
    public int size() {

import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;

import java.util.Arrays;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import jcifs.internal.SMBProtocolDecodingException;

/**

        verify(consumer, times(3)).accept(dosCaptor.capture(), ntCaptor.capture());
        assertIterableEquals(Arrays.asList(0x00000000, 0x00050001, 0x007b0001), dosCaptor.getAllValues());
        assertIterableEquals(Arrays.asList(0x00000000, 0xc0000022, 0xc0000033), ntCaptor.getAllValues());

        // And ensure no further interactions happened
        verifyNoMoreInteractions(consumer);

    public static void secureWipe(byte[] array) {
        if (array != null) {
            Arrays.fill(array, (byte) 0);
            // Additional passes with different patterns for enhanced security
            Arrays.fill(array, (byte) 0xFF);
            Arrays.fill(array, (byte) 0xAA);
            Arrays.fill(array, (byte) 0x55);
            Arrays.fill(array, (byte) 0);
        }
    }

    @Test
    void testGetLocalGroupsMap_Success() throws CIFSException {
        Map<SID, List<SID>> expectedMap = new HashMap<>();
        List<SID> group1Members = Arrays.asList(mockSid1, mockSid2);
        List<SID> group2Members = Arrays.asList(mockSid3);
        expectedMap.put(mockDomainSid, group1Members);
        expectedMap.put(mockSid1, group2Members);

import com.google.j2objc.annotations.RetainedWith;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.Set;
import java.util.SortedSet;
import java.util.Spliterator;

   * about arrays for now, as they're a mess. (We previously discussed this in the review of
   * ObjectArrays, which is the main caller of this method.)
   */
  static <T extends @Nullable Object> T[] newArray(T[] reference, int length) {
    T[] empty = reference.length == 0 ? reference : Arrays.copyOf(reference, 0);
    return Arrays.copyOf(empty, length);
  }

   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link Arrays#equals(long[],
   * long[])}.
   *
   * <p><b>Java 9+ users:</b> Use {@link Arrays#compareUnsigned(long[], long[])
   * Arrays::compareUnsigned}.
   */
  public static Comparator<long[]> lexicographicalComparator() {

        // Then
        assertNotNull(lockResponse);
    }

    @Nested
    @DisplayName("writeBytesWireFormat tests")
    class WriteBytesWireFormatTests {

        @Test
        @DisplayName("Should always return 0 for write bytes")
        void testWriteBytesWireFormat() {
            // Given
            byte[] dst = new byte[100];
            int dstIndex = 0;

            // When

    }

    @Test
    @DisplayName("Test writeSetupWireFormat returns 0")
    void testWriteSetupWireFormat() {
        // Test that writeSetupWireFormat always returns 0
        byte[] buffer = new byte[100];
        int result = response.writeSetupWireFormat(buffer, 0);
        assertEquals(0, result);

        // Test with different offset