Iterable<? extends ListenableFuture<? extends T>> futures) {
    ListenableFuture<? extends T>[] copy = gwtCompatibleToArray(futures);
    InCompletionOrderState<T> state = new InCompletionOrderState<>(copy);
    ImmutableList.Builder<AbstractFuture<T>> delegatesBuilder =
        ImmutableList.builderWithExpectedSize(copy.length);
    for (int i = 0; i < copy.length; i++) {
      delegatesBuilder.add(new InCompletionOrderFuture<T>(state));
    }

            .inOrder();
      }
    }
  }

  private static <E> Set<E> set(E... elements) {
    return ImmutableSet.copyOf(elements);
  }

  private static <E> List<E> list(E... elements) {
    return ImmutableList.copyOf(elements);
  }

  /**
   * Utility method to verify that the given LinkedHashSet is equal to and hashes identically to a

     * @return the converted EditBody
     */
    protected EditBody createEditBody(final WebConfig entity) {
        final EditBody body = new EditBody();
        copyBeanToBean(entity, body, copyOp -> {
            copyOp.excludeNull();
            copyOp.exclude(Constants.PERMISSIONS, Constants.VIRTUAL_HOSTS);
        });
        final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();

   * @since 20.0
   */
  @SafeVarargs
  public static <T extends @Nullable Object> FluentIterable<T> concat(
      Iterable<? extends T>... inputs) {
    return concatNoDefensiveCopy(Arrays.copyOf(inputs, inputs.length));
  }

  /**
   * Returns a fluent iterable that combines several iterables. The returned iterable has an

import junit.framework.TestSuite;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for CompactHashSet.
 *
 * @author Dimitris Andreou
 */
@GwtIncompatible // java.util.Arrays#copyOf(Object[], int), java.lang.reflect.Array
@NullUnmarked
public class CompactHashSetTest extends TestCase {
  @AndroidIncompatible // test-suite builders
  public static Test suite() {
    List<Feature<?>> allFeatures =

                ComponentUtil.getCrawlingConfigHelper().getDefaultConfig(ConfigType.FILE).ifPresent(entity -> {
                    copyBeanToBean(entity, form, copyOp -> {
                        copyOp.excludeNull();
                        copyOp.exclude(Stream.concat(Stream.of(Constants.COMMON_CONVERSION_RULE),
                                Stream.of(Constants.PERMISSIONS, Constants.VIRTUAL_HOSTS)).toArray(n -> new String[n]));

    POSITIVE_INTEGER_CANDIDATES = intValues.build();
    NEGATIVE_INTEGER_CANDIDATES =
        ImmutableList.copyOf(
            Iterables.concat(
                Iterables.transform(POSITIVE_INTEGER_CANDIDATES, NEGATE_INT),
                ImmutableList.of(Integer.MIN_VALUE)));
    NONZERO_INTEGER_CANDIDATES =
        ImmutableList.copyOf(
            Iterables.concat(POSITIVE_INTEGER_CANDIDATES, NEGATIVE_INTEGER_CANDIDATES));

        final String id = form.id;
        labelTypeService.getLabelType(id).ifPresent(entity -> {
            copyBeanToBean(entity, form, copyOp -> {
                copyOp.excludeNull();
                copyOp.exclude(Constants.PERMISSIONS);
            });
            final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();

     */
    assertThat(ImmutableDoubleArray.copyOf(new double[0]))
        .isSameInstanceAs(ImmutableDoubleArray.of());
  }

  public void testCopyOf_array_nonempty() {
    double[] array = new double[] {0, 1, 3};
    ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf(array);
    array[2] = 2;
    assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
  }

        final String id = form.id;
        relatedQueryService.getRelatedQuery(id).ifPresent(entity -> {
            copyBeanToBean(entity, form, copyOp -> {
                copyOp.excludeNull();
                copyOp.exclude(Constants.QUERIES);
            });
            form.queries =