state.incrementRetry();

        // For test purposes, execute recovery immediately without delay
        // In production, this might use the delay from getNextRetryTime()
        executor.submit(() -> attemptRecovery(channel, state));
    }

    private void scheduleRecoveryWithTransport(ChannelInfo channel, FailoverState state, SmbTransport newTransport) {
        state.incrementRetry();

    assertThat(buffer.readUtf8()).isEqualTo(expected)
  }

  @Test
  fun fieldAndTwoFiles() {
    val expected =
      """
      |--AaB03x
      |Content-Disposition: form-data; name="submit-name"
      |
      |Larry
      |--AaB03x
      |Content-Disposition: form-data; name="files"
      |Content-Type: multipart/mixed; boundary=BbC04y
      |
      |--BbC04y

      Future<V> future) {
    if (future instanceof ListenableFuture) {
      return (ListenableFuture<V>) future;
    }
    return new ListenableFutureAdapter<>(future);
  }

  /**
   * Submits a blocking task for the given {@link Future} to provide {@link ListenableFuture}
   * functionality.
   *
   * <p><b>Warning:</b> If the input future does not already implement {@code ListenableFuture}, the

	crypto.RemoveSensitiveEntries(args.Object.UserDefined)
	crypto.RemoveInternalEntries(args.Object.UserDefined)

	if globalHTTPListen.NumSubscribers(pubsub.MaskFromMaskable(args.EventName)) > 0 {
		globalHTTPListen.Publish(args.ToEvent(false))
	}

	globalEventNotifier.Send(args)

    assertFalse(future.isDone());
    assertFalse(future.isCancelled());

    ExecutorService executor = newSingleThreadExecutor();

    try {
      Future<Boolean> getResult = executor.submit(() -> future.get());

      // Release the future value.
      latch.countDown();

      assertTrue(getResult.get(10, SECONDS));
    } finally {
      executor.shutdownNow();
    }

        return execResult.stdout
    }

    static Future<String> readStreamAsync(InputStream inputStream) {
        return THREAD_POOL.submit({ inputStream.text } as Callable) as Future<String>
    }

    when {
      level.intValue() > Level.INFO.intValue() -> Log.WARN
      level.intValue() == Level.INFO.intValue() -> Log.INFO
      else -> Log.DEBUG
    }

object AndroidLogHandler : Handler() {
  override fun publish(record: LogRecord) {
    androidLog(record.loggerName, record.androidLevel, record.message, record.thrown)
  }

  override fun flush() {
  }

  override fun close() {
  }
}

@SuppressSignatureCheck

              } catch (Exception e) {
                throw new RuntimeException(e);
              }
            }
          };
      executor.execute(errorTask);
      service.execute(barrierTask); // submit directly to the service
      // the barrier task runs after the error task so we know that the error has been observed by
      // SequentialExecutor by the time the barrier is satisfied
      barrier.await(1, SECONDS);

       */

      //
      seenExceptionsLocal = newConcurrentHashSet();
      /*
       * Other handleException() callers may see this as soon as we publish it. We need to populate
       * it with the initial failure before we do, or else they may think that the initial failure
       * has never been seen before.
       */
      addInitialException(seenExceptionsLocal);

          @Override
          public void run() {
            throw new RuntimeException("Oh no!");
          }
        };

    Future<?> future = TestingExecutors.sameThreadScheduledExecutor().submit(runnable);
    assertThrows(ExecutionException.class, () -> future.get());
  }