reload(updater);
        }
    }

    /**
     * Reloads the stemmer override dictionary from its source file.
     *
     * @param updater An optional updater to apply changes during reload.
     * @throws DictionaryException if the dictionary file cannot be read.
     */
    protected void reload(final StemmerOverrideUpdater updater) {

    @ValidateTypeFailure
    public Integer crudMode;

    /** URL expression pattern to match documents for boosting */
    @Required
    @Size(max = 10000)
    public String urlExpr;

    /** Boost expression to apply to matching documents */
    @Required
    @Size(max = 10000)
    public String boostExpr;

    /** Sort order for displaying boost configurations */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)

  private final TearDownStack stack = new TearDownStack();

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    handler = new TestLogHandler();

    // You could also apply it higher up the Logger hierarchy than this
    ExampleClassUnderTest.logger.addHandler(handler);

    ExampleClassUnderTest.logger.setUseParentHandlers(false); // optional

    stack.addTearDown(
        new TearDown() {

     */
    public OptionalEntity<Group> getGroup(final String id) {
        return groupBhv.selectByPK(id).map(g -> {
            ComponentUtil.getLdapManager().apply(g);
            return g;
        });
    }

    /**
     * Stores a group by inserting or updating it in both LDAP and the database.
     * Uses refresh policy to ensure immediate availability of the stored data.

              + " map in that class.");
    }
    Object result;
    try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {
        // We are careful to set up INSTANCE_OF to match each Predicate to its target Class.
        @SuppressWarnings("unchecked")
        T caught = (T) t;
        return caught;
      }

    /**
     * Converts a Lucene BooleanQuery to an OpenSearch BoolQueryBuilder.
     * @param context The query context.
     * @param booleanQuery The boolean query to convert.
     * @param boost The boost factor to apply.
     * @return The converted BoolQueryBuilder.
     */
    protected QueryBuilder convertBooleanQuery(final QueryContext context, final BooleanQuery booleanQuery, final float boost) {

  private static final Function<@Nullable String, @Nullable Character> FIRST_CHARACTER =
      new Function<@Nullable String, @Nullable Character>() {
        @Override
        public @Nullable Character apply(@Nullable String input) {
          return input == null ? null : input.charAt(0);
        }
      };

  @Override
  protected Table<String, Integer, Character> create(@Nullable Object... data) {

      Iterator<T> removeFrom, Predicate<? super T> predicate) {
    checkNotNull(predicate);
    boolean modified = false;
    while (removeFrom.hasNext()) {
      if (predicate.apply(removeFrom.next())) {
        removeFrom.remove();
        modified = true;
      }
    }
    return modified;
  }

  /**

  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            Set.class,
            new Function<Set, Set>() {
              @Override
              public Set apply(Set delegate) {
                return wrap(delegate);
              }
            });
  }

  public void testEquals() {
    Set<String> set1 = ImmutableSet.of("one");

  /**
   * Returns a {@code Future} whose result is taken from this {@code Future} or, if this {@code
   * Future} fails with the given {@code exceptionType}, from the result provided by the {@code
   * fallback}. {@link Function#apply} is not invoked until the primary input has failed, so if the
   * primary input succeeds, it is never invoked. If, during the invocation of {@code fallback}, an