* @param normalizer The normalizer to add.
     * @throws IllegalArgumentException if normalizer is null
     */
    public void add(final Normalizer normalizer) {
        if (normalizer == null) {
            throw new IllegalArgumentException("normalizer must not be null");
        }
        normalizers.add(normalizer);
    }

                List.class);
        method.setAccessible(true);

        // Call should not throw - task is scheduled asynchronously
        // Will fail when executed due to null user, but scheduling should succeed
        try {
            method.invoke(authenticator, null, initialGroups, initialRoles, groupIds);

      if (finalizerUrl == null) {
        throw new FileNotFoundException(finalizerPath);
      }

      // Find URL pointing to base of class path.
      String urlString = finalizerUrl.toString();
      if (!urlString.endsWith(finalizerPath)) {
        throw new IOException("Unsupported path style: " + urlString);
      }

            crawlingInfo = new CrawlingInfo(sessionId);
            try {
                getCrawlingInfoService().store(crawlingInfo);
            } catch (final Exception e) {
                throw new FessSystemException("No crawling session.", e);
            }
        }

        if (infoMap != null) {
            final List<CrawlingInfoParam> crawlingInfoParamList = new ArrayList<>();

        queryContext = new QueryContext("test", false);
        // fieldLogMap is null when isQuery is false
        queryContext.addFieldLog("field", "text");
        // Should not throw exception
    }

    // Test addFieldLog with existing field
    @Test
    public void test_addFieldLog_existingField() {
        Map<String, List<String>> fieldLogMap = new HashMap<>();

   *     enter the {@link State#RUNNING} state. e.g. if the {@code state} is {@code
   *     State#TERMINATED} when this method is called then this will throw an IllegalStateException.
   * @since 15.0
   */
  void awaitRunning();

  /**
   * Waits for the {@link Service} to reach the {@linkplain State#RUNNING running state} for no more
   * than the given time.
   *

    after.assertRun();
  }

  public void testMisbehavingListenerAlreadyDone() {
    class BadRunnableException extends RuntimeException {}

    Runnable bad =
        () -> {
          throw new BadRunnableException();
        };

    future.set(1);
    future.addListener(bad, directExecutor()); // BadRunnableException must not propagate.
  }

  public void testMisbehavingListenerLaterDone() {

                method.setAccessible(true);
                return method;
            } catch (NoSuchMethodException e) {
                clazz = clazz.getSuperclass();
            }
        }
        throw new NoSuchMethodException("readString method not found");
    }

    private Field getSuperclassField(Class<?> clazz, String fieldName) throws NoSuchFieldException {
        while (clazz != null) {
            try {

        // Don't resolve - let it timeout

        try {
            deferred.promise().getResponse(100, TimeUnit.MILLISECONDS);
            fail("Should throw timeout exception");
        } catch (SuggesterException e) {
            assertTrue("Should mention timeout", e.getMessage().contains("timeout"));
        }
    }

    @Test

    }

    private static Method subscriberMethod() {
      try {
        return DummySubscriber.class.getMethod("handle", Object.class);
      } catch (NoSuchMethodException e) {
        throw new AssertionError(e);
      }
    }
  }