}

    public int[] batchInsert(List<CrawlingInfoParam> list) {
        return batchInsert(list, null, null);
    }

    public int[] batchInsert(List<CrawlingInfoParam> list, RequestOptionCall<BulkRequestBuilder> call) {
        return batchInsert(list, call, null);
    }

    public int[] batchInsert(List<CrawlingInfoParam> list, RequestOptionCall<BulkRequestBuilder> call,

        return doBatchInsert(new BulkList<>(list, call, entityCall), null);
    }

    public int[] batchUpdate(List<RoleType> list) {
        return batchUpdate(list, null, null);
    }

    public int[] batchUpdate(List<RoleType> list, RequestOptionCall<BulkRequestBuilder> call) {
        return batchUpdate(list, call, null);
    }

    public int[] batchUpdate(List<RoleType> list, RequestOptionCall<BulkRequestBuilder> call,

        return doBatchInsert(new BulkList<>(list, call, entityCall), null);
    }

    public int[] batchUpdate(List<UserInfo> list) {
        return batchUpdate(list, null, null);
    }

    public int[] batchUpdate(List<UserInfo> list, RequestOptionCall<BulkRequestBuilder> call) {
        return batchUpdate(list, call, null);
    }

    public int[] batchUpdate(List<UserInfo> list, RequestOptionCall<BulkRequestBuilder> call,

     * @throws IllegalArgumentException if the list contains duplicate repositories
     * @throws IllegalArgumentException if the list contains null repository entries
     */
    default List<RemoteRepository> validate(List<RemoteRepository> repositories) {
        if (repositories == null) {
            return null;
        }
        HashSet<RemoteRepository> set = new HashSet<>(repositories);

    assertThat(FluentIterable.from(list).first()).hasValue("a");
  }

  public void testFirst_null() {
    List<String> list = Lists.newArrayList(null, "a", "b");
    assertThrows(NullPointerException.class, () -> FluentIterable.from(list).first());
  }

  public void testFirst_emptyList() {
    List<String> list = emptyList();
    assertThat(FluentIterable.from(list).first()).isAbsent();
  }

                this.source = source;
                this.profiles = profiles != null ? List.copyOf(profiles) : List.of();
                this.activeProfileIds = activeProfileIds != null ? List.copyOf(activeProfileIds) : List.of();
                this.inactiveProfileIds = inactiveProfileIds != null ? List.copyOf(inactiveProfileIds) : List.of();
                this.systemProperties =

     */
    public void setHeaders(final Map<String, List<String>> headers) {
        if (headers != null) {
            final Map<String, List<String>> map = new HashMap<>();
            headers.entrySet().stream().filter(e -> e.getKey() != null).forEach(
                    e -> map.put(e.getKey().toLowerCase(Locale.ROOT), e.getValue() == null ? List.of() : List.copyOf(e.getValue())));
            this.headers = Map.copyOf(map);

            return kinds;
        }

        final List<Kind> list = new ArrayList<>(kinds.length + newKinds.length);
        list.addAll(Arrays.asList(kinds));
        for (final Kind kind : newKinds) {
            if (!list.contains(kind)) {
                list.add(kind);
            }
        }
        return list.toArray(new Kind[list.size()]);
    }

    /**
     * Merges two suggest items.

    }
  }

  private static final class PermutationIterator<E> extends AbstractIterator<List<E>> {
    final List<E> list;
    final int[] c;
    final int[] o;
    int j;

    PermutationIterator(List<E> list) {
      this.list = new ArrayList<>(list);
      int n = list.size();
      c = new int[n];
      o = new int[n];
      Arrays.fill(c, 0);
      Arrays.fill(o, 1);

      args.add(generateDummyArg(param, generator));
    }
    Object instance = createInstance(factory, args);
    List<Object> equalArgs = generateEqualFactoryArguments(factory, params, args);
    // Each group is a List of items, each item has a list of factory args.
    List<List<List<Object>>> argGroups = new ArrayList<>();
    argGroups.add(ImmutableList.of(args, equalArgs));
    EqualsTester tester =