*/
@Deprecated(since = "4.0.0")
public interface ProjectDependenciesResolver {

    /**
     * Resolves the transitive dependencies of a project.
     *
     * @param request The resolution request holding the parameters, must not be {@code null}.
     * @return The resolution result, never {@code null}.
     * @throws DependencyResolutionException If any project dependency could not be resolved.
     */

        }
        return toReturn;
      }

      @GuardedBy("lock")
      /*
       * The GuardedBy checker warns us that we're not holding cancellationDelegate.lock. But in
       * fact we are holding it because it is the same as this.lock, which we know we are holding,
       * thanks to @GuardedBy above. (cancellationDelegate.lock is initialized to this.lock in the
       * call to `new SupplantableFuture` below.)
       */

        <![CDATA[
    <interactiveMode>true</interactiveMode>
    ]]></configuration>
      <description>
        <![CDATA[
      If false, flags the system to skip prompting the user for any information, or holding up the build
      waiting for any input.

      NOTE: It's also possible to switch to batch (i.e. non-interactive) mode using the '-B' command-line option.
    ]]></description>
    </expression>
  </expressions>

TF_CAPI_EXPORT void TF_SetXlaMinClusterSize(int size);

// Gets/Sets TF/XLA flag for whether(true) or not(false) to disable constant
// folding. This is for testing to ensure that XLA is being tested rather than
// Tensorflow's CPU implementation through constant folding.
TF_CAPI_EXPORT unsigned char TF_GetXlaConstantFoldingDisabled();
TF_CAPI_EXPORT void TF_SetXlaConstantFoldingDisabled(
    unsigned char should_enable);

        "value (%s) is outside the range for an unsigned integer value",
        value);
    return fromIntBits(value.intValue());
  }

  /**
   * Returns an {@code UnsignedInteger} holding the value of the specified {@code String}, parsed as
   * an unsigned {@code int} value.
   *
   * @throws NumberFormatException if the string does not contain a parsable unsigned {@code int}
   *     value
   */

### Holding multiple locks

You're allowed to take the Http2Connection lock while holding the Http2Writer lock. But not vice-versa. Because taking the Http2Writer lock can block.

        "value (%s) is outside the range for an unsigned long value",
        value);
    return fromLongBits(value.longValue());
  }

  /**
   * Returns an {@code UnsignedLong} holding the value of the specified {@code String}, parsed as an
   * unsigned {@code long} value.
   *
   * @throws NumberFormatException if the string does not contain a parsable unsigned {@code long}
   *     value
   */

 *
 * @since 4.0.0
 */
@Experimental
public interface ArtifactCoordinatesFactory extends Service {

    /**
     * Creates artifact coordinates.
     *
     * @param request the request holding coordinates creation parameters
     * @return an {@code ArtifactCoordinates}, never {@code null}
     * @throws IllegalArgumentException if {@code request} is null or {@code request.session} is null or invalid
     */

   * the String used to construct them is no longer strongly referenced outside of the CipherSuite.
   */
  @Test
  fun instancesAreInterned_survivesGarbageCollection() {
    // We're not holding onto a reference to this String instance outside of the CipherSuite...
    val cs = forJavaName("FakeCipherSuite_instancesAreInterned")
    System.gc() // Unless cs references the String instance, it may now be garbage collected.

   * returned future will emulate {@link ListenableFuture#addListener} by taking a thread from an
   * internal, unbounded pool at the first call to {@code addListener} and holding it until the
   * future is {@linkplain Future#isDone() done}.
   *
   * <p>Prefer to create {@code ListenableFuture} instances with {@link SettableFuture}, {@link