*/
  /*
   * By declaring <T> instead of <T extends @Nullable Object>, we declare this method as requiring a
   * stream whose elements are non-null. However, the method goes out of its way to still handle
   * nulls in the stream. This means that the method can safely be used with a stream that contains
   * nulls as long as the *last* element is *not* null.
   *

 *       typically because the type forbids nullable type arguments: For example, {@code
 *       ImmutableList.get} returns {@code E}, but that value is never {@code null}. (Accordingly,
 *       {@code ImmutableList} is declared to forbid {@code ImmutableList<@Nullable String>}.)
 *   <li>methods whose return type is a type variable but which can return {@code null} regardless

 *       typically because the type forbids nullable type arguments: For example, {@code
 *       ImmutableList.get} returns {@code E}, but that value is never {@code null}. (Accordingly,
 *       {@code ImmutableList} is declared to forbid {@code ImmutableList<@Nullable String>}.)
 *   <li>methods whose return type is a type variable but which can return {@code null} regardless

 */
public class SearchLogBhv extends BsSearchLogBhv {
    private static final Logger logger = LogManager.getLogger(SearchLogBhv.class);

    private String indexName = null;

    @Override
    protected String asEsIndex() {
        if (indexName == null) {
            final String name = ComponentUtil.getFessConfig().getIndexLogIndex();
            indexName = super.asEsIndex().replaceFirst(Pattern.quote("fess_log"), name);
        }

        if (map != null) {
            final String[] queries = map.get(toLowerCase(query));
            if (queries != null) {
                return queries;
            }
        }
        return StringUtil.EMPTY_STRINGS;
    }

    private String toLowerCase(final String term) {
        return term != null ? term.toLowerCase(Locale.ROOT) : term;
    }

    }

    public String process(final PathMappingHelper pathMappingHelper, final String input) {
        if (regexPattern == null) {
            regexPattern = Pattern.compile(getRegex());
        }
        final Matcher matcher = regexPattern.matcher(input);
        if (matcher.find()) {
            if (pathMapperFunc == null) {
                final String replacement = StringUtil.isNotBlank(getReplacement()) ? getReplacement() : StringUtil.EMPTY;

            if ( this.freeBuffers > 0 ) {
                for ( int i = 0; i < this.cache.length; i++ ) {
                    if ( this.cache[ i ] != null ) {
                        buf = (byte[]) this.cache[ i ];
                        this.cache[ i ] = null;
                        this.freeBuffers--;
                        return buf;
                    }
                }
            }

            lhaExtractor.setMaxContentSize(100);
            lhaExtractor.getText(in, null);
            fail();
        } catch (MaxLengthExceededException e) {
            // pass
        }
        lhaExtractor.setMaxContentSize(-1);
    }

    public void test_getText_null() {
        try {
            lhaExtractor.getText(null, null);
            fail();
        } catch (final CrawlerSystemException e) {

                    () -> asHtml(path_AdminWizard_AdminWizardConfigJsp));
            return null;
        }
    }

    protected Integer getDefaultInteger(final String key, final Integer defaultValue) {
        final String value = systemProperties.getProperty(key);
        if (value != null) {
            try {
                return Integer.parseInt(value);

   */
  static void assertBasicUrlEscaperExceptPercent(UnicodeEscaper e) {
    // URL escapers should throw null pointer exceptions for null input
    try {
      e.escape((String) null);
      fail("Escaping null string should throw exception");
    } catch (NullPointerException x) {
      // pass
    }

    // All URL escapers should leave 0-9, A-Z, a-z unescaped