Reflection.newProxy(
            TypeVariable.class, new TypeVariableInvocationHandler(typeVariableImpl));
    return typeVariable;
  }

  /**
   * Invocation handler to work around a compatibility problem between Android and Java.
   *
   * <p>Java 8 introduced a new method {@code getAnnotatedBounds()} in the {@link TypeVariable}
   * interface, whose return type {@code AnnotatedType[]} is also new in Java 8. As of 2025, Android

        )
      }

      // The cache is corrupted, attempt to delete the contents of the directory. This can throw and
      // we'll let that propagate out as it likely means there is a severe filesystem problem.
      try {
        delete()
      } finally {
        closed = false
      }
    }

    rebuildJournal()

    initialized = true
  }

  @Throws(IOException::class)

Of course, there are some cases where there's no problem in running the previous steps multiple times, in that case, it's a lot easier to handle.

/// tip

Natürlich gibt es Fälle, in denen es kein Problem darstellt, die Vorab-Schritte mehrmals auszuführen. In diesem Fall ist die Handhabung viel einfacher.

/// tip | Tipp

        getProject(f1);

        // it's the building of the grandchild project, having already cached the child project
        // (but not the parent project), which causes the problem.
        getProject(f2);
    }

    @Disabled("Maven 4 does not allow duplicate plugin declarations")
    @Test
    void testDuplicatePluginDefinitionsMerged() throws Exception {

 *  Fix: Provide actionable advice when the exchange is non-null. Prior to 3.14, OkHttp would
    silently leak connections when an interceptor retries without closing the response body. With
    3.14 we detect this problem but the exception was not helpful.

## Version 3.14.0

_2019-03-14_

 *  **This release deletes the long-deprecated `OkUrlFactory` and `OkApacheClient` APIs.** These

    assertThat(server.takeRequest().exchangeIndex).isEqualTo(1) // New connection.
  }

  /**
   * We had a bug where we'd perform infinite retries of route that fail with connection shutdown
   * errors. The problem was that the logic that decided whether to reuse a route didn't track
   * certain HTTP/2 errors. https://github.com/square/okhttp/issues/5547
   */
  @Test
  fun noRecoveryFromTwoRefusedStreams() {
    server.enqueue(

   *   ClassLoader that is sometimes used as a system classloader. That's a problem because
   *   method-reference linking tries to look up the system classloader, and it fails because there
   *   isn't one yet.
   *
   * - lambda: Outside Google, we got a report of a similar problem in
   *   https://github.com/google/guava/issues/6565
   */
  @SuppressWarnings("AnonymousToLambda")

   *       into the other buffer (userspace). Note that if the file is very large, a naive
   *       implementation will effectively put the whole file in memory. On many systems with paging
   *       and virtual memory, this is not a problem - because it is mapped read-only, the kernel
   *       can always page it to disk "for free". However, on systems where killing processes
   *       happens all the time in normal conditions (i.e., android) the OS must make a tradeoff

           *
           * (Users who try to operate directly on the `ScheduledFuture` may have additional
           * problems. For example, if they cancel that `Future`, it won't cancel the user-visible
           * `ListenableScheduledTask`. This is essentially the same problem as the
           * `ListenableScheduledTask` has with executor shutdown:
           * https://github.com/google/guava/issues/3553)
           */