Object testInstance = test.getDeclaredConstructor().newInstance();
      test.getMethod("setUp").invoke(testInstance);
      test.getMethod(getName()).invoke(testInstance);
      test.getMethod("tearDown").invoke(testInstance);
    } finally {
      Thread.currentThread().setContextClassLoader(oldClassLoader);
    }
  }

  private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)

  @RegisterExtension
  var platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  @AfterEach fun tearDown() {
    ProxySelector.setDefault(DEFAULT_PROXY_SELECTOR)
    CookieManager.setDefault(DEFAULT_COOKIE_HANDLER)
    ResponseCache.setDefault(DEFAULT_RESPONSE_CACHE)
  }

  @Test fun durationDefaults() {

@AndroidIncompatible
@GwtIncompatible
@RunWith(JUnit4.class)
@NullUnmarked
public class FinalizableReferenceQueueTest {

  private @Nullable FinalizableReferenceQueue frq;

  @After
  public void tearDown() throws Exception {
    frq = null;
  }

  @Test
  public void testFinalizeReferentCalled() {
    MockReference reference = new MockReference(frq = new FinalizableReferenceQueue());

      assertEquals(expectedOutcome, Outcome.HANG);
    } else {
      assertThat(task.get(UNEXPECTED_HANG_DELAY_MILLIS, TimeUnit.MILLISECONDS)).isNull();
    }
  }

  @Override
  protected void tearDown() throws Exception {
    // We don't want to leave stray threads running after each test. At this point, every thread
    // launched by this test is either:
    //
    // (a) Blocked attempting to enter the monitor.

        .fastFallback(true)
        .build()
    url =
      serverIpv4
        .url("/")
        .newBuilder()
        .host("localhost")
        .build()
  }

  @AfterEach
  internal fun tearDown() {
    serverIpv4.close()
    serverIpv6.close()
  }

  @Test
  fun callIpv6FirstEvenWhenIpv4IpIsListedFirst() {
    dnsResults =
      listOf(
        localhostIpv4,
        localhostIpv6,

    executor = newCachedThreadPool();
    serializer = ExecutionSequencer.create();
    firstFuture = SettableFuture.create();
    firstCallable = new TestCallable(firstFuture);
  }

  @Override
  public void tearDown() throws Exception {
    executor.shutdown();
  }

  public void testCallableStartsAfterFirstFutureCompletes() {
    @SuppressWarnings({"unused", "nullness"})

@Suppress(
  "DEPRECATION_ERROR",
  "UNUSED_VALUE",
  "UNUSED_VARIABLE",
  "VARIABLE_WITH_REDUNDANT_INITIALIZER",
)
class KotlinDeprecationErrorTest {
  private val factory = TestValueFactory()

  @AfterEach
  fun tearDown() {
    factory.close()
  }

  @Test @Disabled
  fun address() {
    val address: Address = factory.newAddress()
    val url: HttpUrl = address.url()
    val dns: Dns = address.dns()

    @BeforeAll
    static void setUp() {
        MessageUtils.setColorEnabled(false);
    }

    @AfterAll
    static void tearDown() {
        MessageUtils.setColorEnabled(true);
    }

    @BeforeEach
    void beforeEach() {
        logger = mock(Logger.class);
        when(logger.isInfoEnabled()).thenReturn(true);

   * be a SynchronousQueue.
   */
  private ExecutorService threadPool;

  @Override
  public void setUp() {
    threadPool = newCachedThreadPool();
  }

  @Override
  public void tearDown() throws InterruptedException {
    threadPool.shutdown();
    assertTrue("Some worker didn't finish in time", threadPool.awaitTermination(10, SECONDS));
  }

  private static <T> int drain(
      BlockingQueue<T> q,

    WebSocketReader(
      isClient = true,
      source = data,
      frameCallback = callback.asFrameCallback(),
      perMessageDeflate = true,
      noContextTakeover = false,
    )

  @AfterEach fun tearDown() {
    callback.assertExhausted()
  }

  @Test fun controlFramesMustBeFinal() {
    data.write("0a00".decodeHex()) // Empty pong.
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()