private static class TestIngestFactory extends IngestFactory {
        List<Ingester> ingesters = new ArrayList<>();

        @Override
        public Ingester[] getIngesters() {
            return ingesters.toArray(new Ingester[0]);
        }
    }

    private static class TestIngester extends Ingester {
        int processCalled = 0;

        @Override

      }

      @Override
      public T remove(int index) {
        return data.remove(index);
      }

      @Override
      public @Nullable Object[] toArray() {
        return data.toArray();
      }
    };
  }

  /**
   * Returns a "nefarious" map entry with the specified key and value, meaning an entry that is

                logger.debug("Redirecting to SearchAction with parameters: {}", paramList);
            }
            return OptionalThing.of(redirectWith(SearchAction.class, new UrlChain(this).params(paramList.toArray(n -> new Object[n]))));
        }
        return OptionalThing.empty();
    }

    /**
     * SSO logout endpoint.
     *
     * This method handles SSO logout requests, coordinating with the SSO provider

  }

  private static void checkNoOutput(Joiner joiner, Iterable<Integer> set) {
    assertEquals("", joiner.join(set));
    assertEquals("", joiner.join(set.iterator()));

    Object[] array = newArrayList(set).toArray(new Integer[0]);
    assertEquals("", joiner.join(array));

    StringBuilder sb1FromIterable = new StringBuilder();
    assertSame(sb1FromIterable, joiner.appendTo(sb1FromIterable, set));

                } else {
                    list.add(s);
                }
            }

            if (list.size() > 0) {
                final SID[] resolved = list.toArray(new SID[list.size()]);
                resolveSids0(authorityServerName, tc, resolved);
                for (si = 0; si < resolved.length; si++) {
                    this.sidCache.put(resolved[si], resolved[si]);

        final List<FilterFunctionBuilder> list = new ArrayList<>();
        functionScoreQuery.accept(list);
        queryBuilder = QueryBuilders.functionScoreQuery(queryBuilder, list.toArray(new FilterFunctionBuilder[list.size()]));
    }

    /**
     * Adds additional query clauses using a boolean query builder.
     * @param boolQuery Consumer that configures the boolean query.
     */

        return methodDescsCache.containsKey(methodName);
    }

    @Override
    public String[] getMethodNames() {
        return methodDescsCache.keySet().toArray(new String[methodDescsCache.size()]);
    }

    /**
     * Returns the {@link PropertyDesc} for the specified property name.
     *
     * @param propertyName
     *            the property name

                        names.add(en);
                        expandedNameOffset += en.length() * 2 + 2;
                    }
                    this.expandedNames = names.toArray(new String[names.size()]);
                }

            }
        } else if (this.version == 1) {
            this.node = readString(buffer, bufferIndex, len);
        }

        return this.size;

    List<@Nullable Object> passedArgs = new ArrayList<>();
    for (Class<?> paramType : method.getParameterTypes()) {
      passedArgs.add(paramValues.generateFresh(paramType));
    }
    return passedArgs.toArray();
  }

  /** Tests a single interaction against a method. */
  private static final class InteractionTester<T> extends AbstractInvocationHandler {

    private final Class<T> interfaceType;

   * @throws NullPointerException if {@code collection} or any of its elements is null
   */
  public static char[] toArray(Collection<Character> collection) {
    if (collection instanceof CharArrayAsList) {
      return ((CharArrayAsList) collection).toCharArray();
    }

    Object[] boxedArray = collection.toArray();
    int len = boxedArray.length;
    char[] array = new char[len];
    for (int i = 0; i < len; i++) {