return new CompositionPredicate<>(predicate, function);
  }

  /**
   * Returns a predicate that evaluates to {@code true} if the {@code CharSequence} being tested
   * contains any match for the given regular expression pattern. The test used is equivalent to
   * {@code Pattern.compile(pattern).matcher(arg).find()}
   *
   * @throws IllegalArgumentException if the pattern is invalid
   * @since 3.0
   */

        // Delete test indices and settings indices for complete cleanup
        try {
            runner.admin().indices().prepareDelete("SuggesterRefactoringTest*", "fess_suggest*").execute().actionGet();
        } catch (Exception e) {
            // Index might not exist, ignore
        }
    }

    /**
     * Test getIndicesForAlias method with existing alias.

                }
            }
        } catch (SmbException e) {
            throw e;
        } catch (IOException e1) {
            log.debug("Ignoring invalid initial token", e1);
        }

        try {
            return createContext(tc, targetDomain, host);
        } catch (GSSException e) {
            throw new SmbException("Context setup failed", e);
        }

                if (dirents[i].getType() == SmbFile.TYPE_NAMED_PIPE) {
                    continue;
                }
            } catch (final SmbAuthException sae) {
                if (LogStream.level > 2) {
                    sae.printStackTrace(log);
                }
            } catch (final SmbException se) {
                if (LogStream.level > 2) {
                    se.printStackTrace(log);
                }

      try {
        testClass.getMethod(testName);
        return true;
      } catch (NoSuchMethodException e) {
        continue;
      }
    }
    return false;
  }

  private static boolean isEqualsDefined(Class<?> cls) {
    try {
      return !cls.getDeclaredMethod("equals", Object.class).isSynthetic();
    } catch (NoSuchMethodException e) {
      return false;
    }
  }

                        processLogEntry(entry);
                        returnAuditEntry(entry);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                } catch (Exception e) {
                    log.error("Error processing audit log entry", e);
                }
            }
        });
    }

    Thread waiter =
        new Thread() {
          @Override
          public void run() {
            try {
              service.awaitTermination(1, DAYS);
            } catch (InterruptedException e) {
              return;
            }
          }
        };
    waiter.start();
    awaitTimedWaiting(waiter);
    service.shutdown();

            if (filename != null && filename.length() > 1) {

                try (FileInputStream in = new FileInputStream(filename)) {
                    p.load(in);
                }
            }

        } catch (final IOException ioe) {
            log.error("Failed to load config", ioe); //$NON-NLS-1$
        }
        p.putAll(System.getProperties());
        if (props != null) {
            p.putAll(props);
        }

            - openapi
            - websocket
            - include_router
            - get
            - put
            - post
            - delete
            - options
            - head
            - patch
            - trace
            - on_event
            - middleware

            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }
        }
        return DfTypeUtil.toLocalDateTime(value);
    }

    @SuppressWarnings("unchecked")