* Callable}.
   *
   * @param callable the callable task
   * @since 10.0
   */
  public static <V extends @Nullable Object> ListenableFutureTask<V> create(Callable<V> callable) {
    return new ListenableFutureTask<>(callable);
  }

  /**
   * Creates a {@code ListenableFutureTask} that will upon running, execute the given {@code

  /** Returns an iterable whose iterator returns the given elements in order. */
  public static <E extends @Nullable Object> MinimalIterable<E> of(E... elements) {
    // Make sure to get an unmodifiable iterator
    return new MinimalIterable<>(asList(elements).iterator());
  }

  /**
   * Returns an iterable whose iterator returns the given elements in order. The elements are copied

public class BinaryTransformer extends AbstractTransformer {

    /**
     * Constructs a new BinaryTransformer.
     */
    public BinaryTransformer() {
        // NOP
    }

    /**
     * Transforms the given ResponseData into a ResultData containing binary content.
     * @param responseData The response data to be transformed.
     * @return The transformed ResultData.
     */
    @Override

    return new TrustedListenableFutureTask<>(callable);
  }

  /**
   * Creates a {@code ListenableFutureTask} that will upon running, execute the given {@code
   * Runnable}, and arrange that {@code get} will return the given result on successful completion.
   *
   * @param runnable the runnable task
   * @param result the result to return on successful completion. If you don't need a particular

    class ProtocolComparisonTests {

        @Test
        @DisplayName("Should use different ports for HTTP and HTTPS")
        void testDifferentPorts() {
            // Given
            Handler httpsHandler = new Handler(null);

            // When
            int httpsPort = httpsHandler.getDefaultPort();
            int httpPort = jcifs.http.Handler.DEFAULT_HTTP_PORT;

func JoinNestedRelationNames(relationNames []string) string {
	return strings.Join(relationNames, nestedRelationSplit)
}

// RTrimSlice Right trims the given slice by given length
func RTrimSlice[T any](v []T, trimLen int) []T {
	if trimLen >= len(v) { // trimLen greater than slice len means fully sliced
		return v[:0]
	}
	if trimLen < 0 { // negative trimLen is ignored

  }

  /** Returns the default executor this event bus uses for dispatching events to subscribers. */
  final Executor executor() {
    return executor;
  }

  /** Handles the given exception thrown by a subscriber with the given context. */
  void handleSubscriberException(Throwable e, SubscriberExceptionContext context) {
    checkNotNull(e);
    checkNotNull(context);
    try {

    assertEquals(true, invokeMethod("hasQueuedThread", this));
    assertNull(responseQueue.poll());
  }

  /**
   * Causes this thread to call the named method, and asserts that this thread thereby waits on the
   * given condition-like object. The lock-like object must have a method equivalent to {@link
   * java.util.concurrent.locks.ReentrantLock#hasWaiters(java.util.concurrent.locks.Condition)},

    /**
     * Constructs an SMB2 IOCTL response with the given configuration.
     *
     * @param config the configuration for this response
     */
    public Smb2IoctlResponse(final Configuration config) {
        super(config);
        this.outputBuffer = null;
    }

    /**
     * Constructs an SMB2 IOCTL response with the given configuration and output buffer.
     *

  /** Constructor for use by subclasses. */
  protected CharSource() {}

  /**
   * Returns a {@link ByteSource} view of this char source that encodes chars read from this source
   * as bytes using the given {@link Charset}.
   *
   * <p>If {@link ByteSource#asCharSource} is called on the returned source with the same charset,
   * the default implementation of this method will ensure that the original {@code CharSource} is