/**
     * Adds an extractor to the factory for the specified key.
     * If an extractor already exists for the key, the new extractor is added to the array of extractors,
     * and the array is sorted by weight in descending order.
     * If no extractor exists for the key, a new array containing the extractor is created and associated with the key.
     *
     * @param key       The key associated with the extractor. Must not be null or blank.

    /**
     * Enhanced listFiles method that uses directory leasing for caching when available
     *
     * @param smbFile the SmbFile directory to list
     * @return array of SmbFile objects representing the directory contents
     * @throws SmbException if an error occurs
     */
    public static SmbFile[] listFilesWithLeasing(SmbFile smbFile) throws SmbException {

  }

  private static final class ArrayItr<T extends @Nullable Object>
      extends AbstractIndexedListIterator<T> {
    static final UnmodifiableListIterator<Object> EMPTY = new ArrayItr<>(new Object[0], 0);

    private final T[] array;

    ArrayItr(T[] array, int position) {
      super(array.length, position);
      this.array = array;
    }

    @Override

      }
    }
    return null;
  }

  private static <T> T createEmptyArray(Class<T> arrayType) {
    // getComponentType() is non-null because we call createEmptyArray only with an array type.
    return arrayType.cast(Array.newInstance(requireNonNull(arrayType.getComponentType()), 0));
  }

  // Internal implementations of some classes, with public default constructor that get() needs.
  private static final class Dummies {

        String[] array = { "a", "b", "c" };
        doc.put("key", array);

        List<String> result = DocumentUtil.getValue(doc, "key", List.class);
        assertEquals(Arrays.asList("a", "b", "c"), result);
    }

    public void test_first_element_from_list() {
        Map<String, Object> doc = new HashMap<>();
        List<String> list = Arrays.asList("first", "second", "third");

  // Class.cast is not supported in GWT.
  static void checkCast(Class<?> clazz, Object obj) {}

  static <T> T[] clone(T[] array) {
    return (T[]) Arrays.copyOfRange(array, 0, array.length);
  }

  // TODO: Consolidate different copies in one single place.
  static String format(String template, Object... args) {
    // start substituting the arguments into the '%s' placeholders

      CompoundOrdering<?> that = (CompoundOrdering<?>) object;
      return Arrays.equals(this.comparators, that.comparators);
    }
    return false;
  }

  @Override
  public int hashCode() {
    return Arrays.hashCode(comparators);
  }

  @Override
  public String toString() {
    return "Ordering.compound(" + Arrays.toString(comparators) + ")";
  }

  @JvmStatic
  fun repeat(
    c: Char,
    count: Int,
  ): String {
    val array = CharArray(count)
    Arrays.fill(array, c)
    return String(array)
  }

  /**
   * Okio buffers are internally implemented as a linked list of arrays. Usually this implementation
   * detail is invisible to the caller, but subtle use of certain APIs may depend on these internal
   * structures.

            split(value, ",").of(stream -> stream.forEach(list::add));
        }
        return list.stream().filter(StringUtil::isNotBlank).map(String::trim).toArray(n -> new String[n]);
    }

    /**
     * Gets the default roles as an array.
     * @return The default roles as an array.
     */
    protected String[] getDefaultRolesAsArray() {
        final List<String> list = new ArrayList<>();

            Object[] array = s.toArray();
            for (int i = 0; i < 2; i++) {
                assertEquals(values[i], array[i]);
            }
        });
    }

    public void test_ofNull() {
        assertEquals(0, (int) StreamUtil.stream().get(s -> s.toArray().length));
        Object[] o = {};
        assertEquals(0, (int) StreamUtil.stream(o).get(s -> s.toArray().length));