// Should only copy first 16 bytes
            assertArrayEquals(Arrays.copyOfRange(longFileId, 0, 16), Arrays.copyOfRange(buffer, 16, 32));
        }

        @Test
        @DisplayName("Should handle file ID shorter than 16 bytes")
        void testShortFileId() {
            byte[] shortFileId = new byte[8];
            Arrays.fill(shortFileId, (byte) 0xAB);
            request.setFileId(shortFileId);

    List<Boolean> none = Arrays.<Boolean>asList();
    assertThat(Booleans.toArray(none)).isEqualTo(EMPTY);

    List<Boolean> one = Arrays.asList(false);
    assertThat(Booleans.toArray(one)).isEqualTo(ARRAY_FALSE);

    boolean[] array = {false, false, true};

    List<Boolean> three = Arrays.asList(false, false, true);
    assertThat(Booleans.toArray(three)).isEqualTo(array);

    }

    @Nested
    @DisplayName("Edge Cases and Error Conditions")
    class EdgeCasesTests {

        @Test
        @DisplayName("Should handle maximum size arrays")
        void testMaximumSizeArrays() {
            // Test with reasonably large arrays
            int[] largeCiphers = new int[100];
            for (int i = 0; i < 100; i++) {
                largeCiphers[i] = i;
            }

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

    }
  }

  /** Returns the {@code Class} object of arrays with {@code componentType}. */
  static Class<?> getArrayClass(Class<?> componentType) {
    // TODO(user): This is not the most efficient way to handle generic
    // arrays, but is there another way to extract the array class in a
    // non-hacky way (i.e. using String value class names- "[L...")?
    return Array.newInstance(componentType, 0).getClass();
  }

  /*

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.dfs;

import java.util.Arrays;

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

/**
 * DFS (Distributed File System) referral response buffer parser.
 * Decodes server responses to DFS referral requests, extracting information about

        // Then
        assertEquals(dataLength, bytesWritten);
        byte[] expectedData = Arrays.copyOfRange(TEST_DATA, dataOffset, dataOffset + dataLength);
        byte[] writtenData = Arrays.copyOfRange(dst, dstIndex, dstIndex + dataLength);
        assertArrayEquals(expectedData, writtenData);
    }

    @Test

/**
 * Utility class for conversions related to byte arrays.
 *
 * @author higa
 */
public abstract class BinaryConversionUtil {

    /**
     * Do not instantiate.
     */
    protected BinaryConversionUtil() {
    }

    /**
     * Converts to a {@literal byte} array.
     *
     * @param o
     *            The object to convert
     * @return The {@literal byte} array
     */

  }

  /**
   * @return an array of the proper size with {@code null} as the key of the middle element.
   */
  protected Entry<K, V>[] createArrayWithNullKey() {
    Entry<K, V>[] array = createSamplesArray();
    int nullKeyLocation = getNullLocation();
    Entry<K, V> oldEntry = array[nullKeyLocation];
    array[nullKeyLocation] = mapEntry(null, oldEntry.getValue());
    return array;
  }

  /**

        assertEquals("00FF7F80", result);
    }

    @Test
    @DisplayName("Should handle large byte arrays efficiently")
    void testLargeByteArray() {
        // Create a larger test array
        byte[] data = createTestData(1024);

        // Test full array conversion
        String result = Hexdump.toHexString(data);
        assertEquals(2048, result.length()); // 1024 bytes * 2 chars