return null;
        }

        @Override
        public void log(String msg) {
        }

        @Override
        public void log(String message, Throwable throwable) {
        }

        @Override
        public String getServerInfo() {
            return "MockServer/1.0";
        }

        @Override
        public String getInitParameter(String name) {

     *
     * @param se the SmbException to convert
     * @return the resulting IOException
     */
    protected IOException seToIoe(final SmbException se) {
        IOException ioe = se;
        Throwable root = se.getRootCause();
        if (root instanceof TransportException) {
            ioe = (TransportException) root;
            root = ((TransportException) ioe).getRootCause();
        }

       */
      setException(e);
      return;
    }

    T transformResult;
    try {
      transformResult = doTransform(localFunction, sourceResult);
    } catch (Throwable t) {
      restoreInterruptIfIsInterruptedException(t);
      // This exception is irrelevant in this thread, but useful for the client.
      setException(t);
      return;
    } finally {
      function = null;

        assertTrue(exception instanceof FessSystemException);
        assertTrue(exception instanceof RuntimeException);
        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    @Test
    public void test_stackTracePresence() {
        // Setup
        final String message = "Query error with stack trace";

        return ByteOrder.nativeOrder().equals(ByteOrder.LITTLE_ENDIAN)
            ? UnsafeByteArray.UNSAFE_LITTLE_ENDIAN
            : UnsafeByteArray.UNSAFE_BIG_ENDIAN;
      }
    } catch (Throwable t) {
      // ensure we really catch *everything*
    }

    return JavaLittleEndianBytes.INSTANCE;
  }

  /** Deter instantiation of this class. */
  private LittleEndianByteArray() {}

                new EqualsTester().addEqualityGroup(new EqualsBasedOnToString("foo")).testEquals());
    assertThat(e).hasMessageThat().contains("toString representation");
  }

  private static void assertErrorMessage(Throwable e, String message) {
    // TODO(kevinb): use a Truth assertion here
    if (!e.getMessage().contains(message)) {
      fail("expected <" + e.getMessage() + "> to contain <" + message + ">");
    }
  }

  /**

    assertThat(future.resultNow()).isEqualTo(expectedResult);
    assertThrows(IllegalStateException.class, future::exceptionNow);
  }

  private static void assertFailed(
      AbstractFuture<@Nullable Integer> future, Throwable expectedException)
      throws InterruptedException, TimeoutException {
    assertDone(future);
    assertThat(future.isCancelled()).isFalse();

    try {
      getDone(future);
      fail();

      this.state = referent.state;
    }

    @Override
    public void finalizeReferent() {
      references.remove(this);
      try {
        state.reset();
      } catch (Throwable t) {
        t.printStackTrace(System.err);
      }
    }
  }

  private static final class FbosByteSource extends ByteSource {
    final State state;

    FbosByteSource(State state) {

    assertThat(future.resultNow()).isEqualTo(expectedResult);
    assertThrows(IllegalStateException.class, future::exceptionNow);
  }

  private static void assertFailed(
      AbstractFuture<@Nullable Integer> future, Throwable expectedException)
      throws InterruptedException, TimeoutException {
    assertDone(future);
    assertThat(future.isCancelled()).isFalse();

    try {
      getDone(future);
      fail();

        try {
            super.insert(urlQueue, urlQueue.getId() == null ? OpType.CREATE : OpType.INDEX);
        } catch (final OpenSearchAccessException e) {
            final Throwable cause = e.getCause();
            if (cause != null && "VersionConflictEngineException".equals(cause.getClass().getSimpleName())) {
                if (logger.isDebugEnabled()) {