return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {
    checkNotNull(expectedThrowable);
    checkNotNull(supplier);
    Predicate<Throwable> predicate = INSTANCE_OF.get(expectedThrowable);
    if (predicate == null) {

    String line;
    while ((line = r.readLine()) != null) {
      lines.add(line);
    }
    r.close();
    return lines;
  }

  private static List<String> readUsingReader(String input, int chunk, boolean asReader)
      throws IOException {
    Readable readable =
        asReader ? getChunkedReader(input, chunk) : getChunkedReadable(input, chunk);
    LineReader r = new LineReader(readable);

    @Nullable Object element;
    List<Object> extras;

    ToOptionalState() {
      element = null;
      extras = emptyList();
    }

    IllegalArgumentException multiples(boolean overflow) {
      StringBuilder sb =
          new StringBuilder().append("expected one element but was: <").append(element);
      for (Object o : extras) {
        sb.append(", ").append(o);
      }

  }

  /**
   * Duration-based overload of {@link #awaitTermination(long, TimeUnit)}.
   *
   * @since 32.1.0
   */
  @J2ktIncompatible
  default boolean awaitTermination(Duration timeout) throws InterruptedException {
    return awaitTermination(toNanosSaturated(timeout), TimeUnit.NANOSECONDS);
  }

        this.returnCode = returnCode;
    }

    /**
     * Checks if the RPC operation was successful.
     *
     * @return true if successful (return code is ERROR_SUCCESS)
     */
    public boolean isSuccess() {
        return returnCode == ERROR_SUCCESS;
    }

    /**
     * Gets the error message for the current return code.
     *
     * @return a human-readable error message
     */

        // Then
        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);

        // Should contain this test method in stack trace
        boolean foundTestMethod = false;
        for (StackTraceElement element : exception.getStackTrace()) {
            if (element.getMethodName().contains("testStackTracePreservation")) {
                foundTestMethod = true;

     */
    public static final String ACCESS_RESULT_DATA = "accessResultData";

    /**
     * Flag indicating whether the access result data has been initialized.
     */
    private boolean initializedData = false;

    /**
     * Initializes the access result with response data and result data.
     *
     * @param responseData The response data from the crawl operation.

    private FesenClient fesenClient;

    private OpenSearchRunner runner;

    @Override
    protected String prepareConfigFile() {
        return "app.xml";
    }

    @Override
    protected boolean isUseOneTimeContainer() {
        return true;
    }

    @Override
    public void setUp() throws Exception {
        // create runner instance
        runner = new OpenSearchRunner();
        // create ES nodes

    public int skipBytes(int n) {
      try {
        return input.skipBytes(n);
      } catch (IOException e) {
        throw new IllegalStateException(e);
      }
    }

    @Override
    public boolean readBoolean() {
      try {
        return input.readBoolean();
      } catch (IOException e) {
        throw new IllegalStateException(e);
      }
    }

    @Override
    public byte readByte() {

              return ranges.get(index + off).intersection(range);
            } else {
              return ranges.get(index + off);
            }
          }

          @Override
          boolean isPartialView() {
            return true;
          }

          // redeclare to help optimizers with b/310253115
          @SuppressWarnings("RedundantOverride")
          @Override