* Math#addExact(long, long)} instead. Note that if both arguments are {@code int} values, writing
   * {@code Math.addExact(a, b)} will call the {@link Math#addExact(int, int)} overload, not {@link
   * Math#addExact(long, long)}. Also note that adding two {@code int} values can <b>never</b>
   * overflow a {@code long}, so you can just write {@code (long) a + b}.
   *

     *     `sslSocketFactory(SSLSocketFactory, X509TrustManager)`, which avoids such reflection.
     */
    @Deprecated(
      message = "Use the sslSocketFactory overload that accepts a X509TrustManager.",
      level = DeprecationLevel.ERROR,
    )
    fun sslSocketFactory(sslSocketFactory: SSLSocketFactory) =
      apply {
        if (sslSocketFactory != this.sslSocketFactoryOrNull) {

- Made legacy watch calls (`ResourceVersion` = 0 or unset) that generate init-events weigh higher in `API Priority and Fairness (APF)` seat usage. Properly accounting for their cost protects the API server from CPU overload. Users might see increased throttling of such calls as a result. ([#134601](https://github.com/kubernetes/kubernetes/pull/134601), [@shyamjvs](https://github.com/shyamjvs))

    } catch (SecurityException e) {
      // OK if we can't set the name in this environment.
    }
    return result;
  }

  // TODO(lukes): provide overloads for ListeningExecutorService? ListeningScheduledExecutorService?
  // TODO(lukes): provide overloads that take constant strings? Function<Runnable, String>s to
  // calculate names?

  /**

 *       hunt through classes like {@link Arrays} and {@link Ints} for them.
 *   <li>Supports a copy-free {@link #subArray} view, so methods that accept this type don't need to
 *       add overloads that accept start and end indexes.
 *   <li>Can be streamed without "breaking the chain": {@code foo.getBarInts().stream()...}.
 *   <li>Access to all collection-based utilities via {@link #asList} (though at the cost of

 *       hunt through classes like {@link Arrays} and {@link Longs} for them.
 *   <li>Supports a copy-free {@link #subArray} view, so methods that accept this type don't need to
 *       add overloads that accept start and end indexes.
 *   <li>Can be streamed without "breaking the chain": {@code foo.getBarLongs().stream()...}.
 *   <li>Access to all collection-based utilities via {@link #asList} (though at the cost of

        return crawlingConfigMap.get(sessionCountId);
    }

    /**
     * Retrieves all available web crawling configurations.
     * This is a convenience method that calls the overloaded version with default parameters
     * (withLabelType=true, withRoleType=true, available=true, idList=null).
     *
     * @return a list of all available WebConfig objects
     */

import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Superclass for tests for {@link Maps#transformValues} overloads.
 *
 * @author Isaac Shum
 */
@GwtCompatible
@NullMarked
abstract class AbstractMapsTransformValuesTest extends MapInterfaceTest<String, String> {
  public AbstractMapsTransformValuesTest() {

   * - quartiles with index and with indexes taking int-varargs, and with compute taking a
   *   double-collection and with computeInPlace;
   * - scale with index and with indexes taking int-varargs, and with all overloads of compute
   *   taking a double-collection and with computeInPlace;
   * - scale with indexes taking integer-collection with compute taking a double-collection and with
   *   computeInPlace;

   * - quartiles with index and with indexes taking int-varargs, and with compute taking a
   *   double-collection and with computeInPlace;
   * - scale with index and with indexes taking int-varargs, and with all overloads of compute
   *   taking a double-collection and with computeInPlace;
   * - scale with indexes taking integer-collection with compute taking a double-collection and with
   *   computeInPlace;