throw RejectedExecutionException()
      }

      if (scheduleAndDecide(task, delayNanos, recurrence = false)) {
        taskRunner.kickCoordinator(this)
      }
    }
  }

  /**
   * Overload of [schedule] that uses a lambda for a repeating task.
   *
   * TODO: make this inline once this is fixed: https://github.com/oracle/graal/issues/3466
   */
  fun schedule(
    name: String,
    delayNanos: Long = 0L,

    new EqualsTester()
        .addEqualityGroup(wrapperFunction.apply(instance), wrapperFunction.apply(instance))
        .addEqualityGroup(wrapperFunction.apply(generator.newFreshProxy(interfaceType)))
        // TODO: add an overload to EqualsTester to print custom error message?
        .testEquals();
  }

  private static <T> void testToString(
      Class<T> interfaceType, Function<? super T, ? extends T> wrapperFunction) {

	switch {
	case !utf8Valid1 || !utf8Valid2:
		// Name and Comment definitely not UTF-8.
		f.NonUTF8 = true
	case !utf8Require1 && !utf8Require2:
		// Name and Comment use only single-byte runes that overlap with UTF-8.
		f.NonUTF8 = false
	default:
		// Might be UTF-8, might be some other encoding; preserve existing flag.
		// Some ZIP writers use UTF-8 encoding without setting the UTF-8 flag.

   */
  public String join(Iterable<?> parts) {
    /*
     * If we can quickly determine how many elements there are likely to be, then we can use the
     * fastest possible implementation, which delegates to the array overload of String.join.
     *
     * In theory, we can quickly determine the size of any Collection. However, thanks to
     * regrettable implementations like our own Sets.filter, Collection.size() is sometimes a

  private static final class LegacyAsyncDispatcher extends Dispatcher {

    // This dispatcher matches the original dispatch behavior of AsyncEventBus.
    //
    // We can't really make any guarantees about the overall dispatch order for this dispatcher in
    // a multithreaded environment for a couple of reasons:
    //
    // 1. Subscribers to events posted on different threads can be interleaved with each other

   * advantage of <a
   * href="https://docs.oracle.com/javase/tutorial/java/generics/genTypeInference.html#type-inference-instantiation">"diamond"
   * syntax</a>. (Unlike here, there is no risk of overload ambiguity, since the {@code ArrayList}
   * constructors very wisely did not accept varargs.)
   *
   * @param initialArraySize the exact size of the initial backing array for the returned array list

   * this address.
   *
   * If [planToReplace] is non-null, this will swap it for a pooled connection if that pooled
   * connection uses HTTP/2. That results in fewer sockets overall and thus fewer TCP slow starts.
   */
  internal fun planReusePooledConnection(
    planToReplace: ConnectPlan? = null,
    routes: List<Route>? = null,
  ): ReusePlan? {
    val result =

	if err != nil {
		return err
	}

	headers := make(amqp091.Table)
	// Add more information here as required, but be aware to not overload headers
	headers["minio-bucket"] = eventData.S3.Bucket.Name
	headers["minio-event"] = eventData.EventName.String()

	if err = ch.ExchangeDeclare(target.args.Exchange, target.args.ExchangeType, target.args.Durable,

                allEntries.addAll(normalValues);
                SortedMultiset<E> multiset =
                    (SortedMultiset<E>) delegate.create(allEntries.toArray());

                // call the smallest subMap overload that filters out the extreme
                // values
                if (from == Bound.INCLUSIVE) {
                  multiset = multiset.tailMultiset(firstInclusive, BoundType.CLOSED);

        where:
        implicitMethod | paramTypes
        "values"       | []
        "valueOf"      | ["java.lang.String"]
    }

    def "the @since annotation on implicit enum method '#implicitMethod' overload is required"() {
        given:
        def rule = withContext(new SinceAnnotationRule([:]))
        def jApiMethod = Stub(JApiMethod)
        jApiMethod.name >> implicitMethod