* @return a SuggestItem created from the given search words and associated data
     */
    SuggestItem parseSearchWords(String[] words, String[][] readings, String[] fields, String[] tags, String[] roles, long score,
            ReadingConverter readingConverter, Normalizer normalizer, SuggestAnalyzer analyzer, String[] langs);

    /**
     * Parses the given query log and returns a list of suggest items.
     *

            @Override
            public String getAppEncryptPropertyPattern() {
                return ".*password|.*key";
            }
        };
        ComponentUtil.setFessConfig(fessConfig);
    }

    public void test_convertParameterMap() {
        String parameters;
        Map<String, String> parameterMap;

        parameters = "";

    private final ConcurrentHashMap<String, MockRegistration> registrations = new ConcurrentHashMap<>();
    private Thread serverThread;

    /**
     * Mock registration data
     */
    private static class MockRegistration {
        final String registrationId;
        final String shareName;
        final String serverAddress;
        final int flags;
        final long timestamp;

    @Inject
    private Logger logger;

    @Inject
    private ProfileSelector profileSelector;

    private List<String> activatedIds = new ArrayList<>();

    private List<String> deactivatedIds = new ArrayList<>();

    private List<String> defaultIds = new ArrayList<>();

    private Map<String, Profile> profilesById = new LinkedHashMap<>();

    private Properties requestProperties;

    /**

        final Map<String, String> headerMap = new HashMap<>();
        provider.adjustActionResponseHeaders("application/json", (k, v) -> headerMap.put(k, v));
        assertEquals(1, headerMap.size());
        assertEquals("def", headerMap.get("X-Def"));
    }

    private FessConfig createFessConfigWithResponseHeaders(final String text) {
        return new FessConfig.SimpleImpl() {

      return arithmetic.add(a, b);
    }

    @Override
    public String toString() {
      return arithmetic.toString();
    }
  }

  private interface ParameterTypesDifferent {
    void foo(
        String s,
        Runnable r,
        Number n,
        Iterable<?> it,
        boolean b,
        Equivalence<String> eq,
        Exception e,
        InputStream in,
        Comparable<?> c,

    public void testConvertWithEmptyLanguageArray() throws IOException {
        // Test convert with empty language array
        converter.init();
        String text = "test";
        String field = "content";
        String[] langs = new String[0];

        List<String> readings = converter.convert(text, field, langs);

        assertNotNull(readings);
        assertEquals(1, readings.size());

        String min = "10";
        String max = "100";
        FessMessages result = messages.addConstraintsRangeMessage(property, min, max);
        assertNotNull(result);
        assertSame(messages, result);
        assertTrue(messages.hasMessageOf(property));
    }

    public void test_addConstraintsModCheckMessage() {
        String property = "testProperty";

    protected void checkEsInvalidAggregation(String name, Object value) {
        if (value == null || (value instanceof String && ((String) value).isEmpty())) {
            String msg = "Cannot register null or empty aggregation: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

    protected void checkEsInvalidAggregationCollection(String name, Collection<?> values) {

  // Extending CharEscaper (instead of Escaper) makes Escapers.compose() easier.
  private static final Escaper NULL_ESCAPER =
      new CharEscaper() {
        @Override
        public String escape(String string) {
          return checkNotNull(string);
        }

        @Override
        protected char @Nullable [] escape(char c) {
          // TODO: Fix tests not to call this directly and make it throw an error.
          return null;