firstException = expected;
    // Second time should also fail, with a cached causal chain.
    expected = assertThrows(PotentialDeadlockException.class, () -> lockA.lock());
    checkMessage(expected, "LockB -> LockA", "LockA -> LockB");
    // The causal chain should be cached.
    assertSame(firstException.getCause(), expected.getCause());
    // lockA should work after lockB is released.

 * handshakes.
 */
class Handshake internal constructor(
  /**
   * Returns the TLS version used for this connection. This value wasn't tracked prior to OkHttp
   * 3.0. For responses cached by preceding versions this returns [TlsVersion.SSL_3_0].
   */
  @get:JvmName("tlsVersion") val tlsVersion: TlsVersion,
  /** Returns the cipher suite used for the connection. */

That way, your application won't have to generate the schema every time a user opens your API docs.

It will be generated only once, and then the same cached schema will be used for the next requests.

{* ../../docs_src/extending_openapi/tutorial001.py hl[13:14,25:26] *}

### Override the method { #override-the-method }

        }
        return Collections.emptyList();
    }

    /**
     * Clears all cached popular word lists.
     */
    public void clearCache() {
        cache.invalidateAll();
    }

    /**
     * Generates a cache key based on the provided parameters.
     *
     * @param seed the seed value
     * @param tags array of tags
     * @param roles array of roles

    /**
     * Initializes the disallowed compound operations based on the provided property string.
     *
     * @param prop comma-separated list of operations to disallow in compound requests
     */
    protected void initDisallowCompound(final String prop) {
        if (prop == null) {
            return;
        }
        final Set<String> disallow = new HashSet<>();

		if len(dui.BucketsUsage) > 0 {
			internalLogOnceIf(GlobalContext, fmt.Errorf("unable to retrieve usage information for bucket: %s, relying on older value cached in-memory: err(%v)", bucket, err), "bucket-usage-cache-"+bucket)
		} else {

    protected static final String GROOVY_MATCHER = "groovy:";

    /** Map of path mappings by process type. */
    protected final Map<String, List<PathMapping>> pathMappingMap = new HashMap<>();

    /** Cached list of path mappings. */
    protected volatile List<PathMapping> cachedPathMappingList = null;

    /**
     * Initializes the path mapping helper.
     */
    @PostConstruct
    public void init() {

    if: github.repository == 'tensorflow/tensorflow' && (github.event.action != 'labeled' || (github.event.action == 'labeled' && github.event.label.name == 'kokoro:force-run'))
    runs-on: [self-hosted, linux, ARM64]
    strategy:
      matrix:
        pyver: ['3.10']
    steps:
      - name: Stop old running containers (if any)
        shell: bash
        run: |
          running_containers=$(docker ps -q) && \

- Choice of erasure set size is automatic based on the number of drives available, let's say for example if there are 32 servers and 32 drives which is a total of 1024 drives. In this scenario 16 becomes the erasure set size. This is decided based on the greatest common divisor (GCD) of acceptable erasure set sizes ranging from *4 to 16*.

     * @return A new {@code UnaryOperator<String>} that caches the results of the original function.
     *         If the original function returns null for a given input, null will be cached and returned for subsequent calls with the same input.
     *
     * @see Function
     * @see Optional
     * @see HashMap#computeIfAbsent(Object, Function)
     */