byte[] emptyArray = new byte[0];

            // When & Then - should handle gracefully
            Method writeParams = SmbComNtCancel.class.getDeclaredMethod("writeParameterWordsWireFormat", byte[].class, int.class);
            writeParams.setAccessible(true);
            assertEquals(0, writeParams.invoke(cancel, emptyArray, 0));

    }

    public void test_emptyArrayValues() {
        // Test with empty array
        ExtractData data = new ExtractData();

        String[] emptyArray = {};
        data.putValues("empty", emptyArray);

        String[] retrieved = data.getValues("empty");
        assertNotNull(retrieved);
        assertEquals(0, retrieved.length);
    }

    public void test_nullValues() {

        // Create empty DfsEnumArray200
        netdfs.DfsEnumArray200 emptyArray = new netdfs.DfsEnumArray200();
        emptyArray.count = 0;
        emptyArray.s = new netdfs.DfsInfo200[0];

        // Replace the info.e field with our empty array
        setDfsEnumArray(dfsRootEnum, emptyArray);

        // Test getEntries returns empty array
        FileEntry[] entries = dfsRootEnum.getEntries();

    final Ordering<T> ordering;
    final List<T> strictlyOrderedList;
    final T[] emptyArray;

    Scenario(Ordering<T> ordering, List<T> strictlyOrderedList, T[] emptyArray) {
      this.ordering = ordering;
      this.strictlyOrderedList = strictlyOrderedList;
      this.emptyArray = emptyArray;
    }

    void testCompareTo() {
      testComparator(ordering, strictlyOrderedList);
    }

    final Ordering<T> ordering;
    final List<T> strictlyOrderedList;
    final T[] emptyArray;

    Scenario(Ordering<T> ordering, List<T> strictlyOrderedList, T[] emptyArray) {
      this.ordering = ordering;
      this.strictlyOrderedList = strictlyOrderedList;
      this.emptyArray = emptyArray;
    }

    void testCompareTo() {
      testComparator(ordering, strictlyOrderedList);
    }

     *
     * @throws Exception
     */
    public void testFromBinaryToObject_EmptyArray() throws Exception {
        final String[] emptyArray = new String[0];
        final byte[] binary = SerializeUtil.fromObjectToBinary(emptyArray);
        final String[] result = (String[]) SerializeUtil.fromBinaryToObject(binary);
        assertEquals(0, result.length);
    }

    /**

        assertNull(crawlerContext.removeSitemaps());

        // Test with empty array
        crawlerContext.addSitemaps(new String[0]);
        String[] emptyArray = crawlerContext.removeSitemaps();
        assertNotNull(emptyArray);
        assertEquals(0, emptyArray.length);
    }

    /**
     * Test thread-local nature of sitemaps
     */
    public void test_sitemaps_threadLocal() throws Exception {

final class RegularImmutableSet<E> extends ImmutableSet.CachingAsList<E> {
  private static final Object[] EMPTY_ARRAY = new Object[0];
  static final RegularImmutableSet<Object> EMPTY =
      new RegularImmutableSet<>(EMPTY_ARRAY, 0, EMPTY_ARRAY, 0);

  private final transient Object[] elements;
  private final transient int hashCode;
  // the same values as `elements` in hashed positions (plus nulls)

public abstract class TraversalUtil {

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

    /** An empty array of {@link Traverser}. */
    protected static final Traverser[] EMPTY_ARRAY = new Traverser[0];

    private static final Logger logger = Logger.getLogger(TraversalUtil.class);

    /** Mapping from URL protocol (as key) to {@link TraverserFactory} (as value). */

    return Spliterators.spliterator(this, SPLITERATOR_CHARACTERISTICS);
  }

  private static final Object[] EMPTY_ARRAY = {};

  @Override
  @J2ktIncompatible // Incompatible return type change. Use inherited (unoptimized) implementation
  public final Object[] toArray() {
    return toArray(EMPTY_ARRAY);
  }

  @CanIgnoreReturnValue
  @Override
  /*
   * This suppression is here for two reasons:
   *