}.also { expected ->
      assertThat(expected.message).isEqualTo("timeout")
    }

    // Confirm that a subsequent request on the same connection is not impacted.
    val call2 = client.newCall(Request(server.url("/")))
    val response2 = call2.execute()
    assertThat(response2.body.string()).isEqualTo("A")

    // Confirm that the connection was reused.
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)

 * and that the {@code toString} helper contains the expected values.
 *
 * <p>The tests also exercise edge cases such as negative (wrap‑around) session
 * identifiers and confirm that the writer does not alter any internal state.
 *</p>
 */
@ExtendWith(MockitoExtension.class)
class SmbComFindClose2Test {

    @Mock
    private Configuration mockConfig;

            )
            text(
                "confirmationCode",
                "",
                label = "Confirmation Code",
                description = "Enter the value 'startCycle' (no quotes) to confirm the promotion",
                display = ParameterDisplay.PROMPT,
                allowEmpty = false,
            )
            text(
                "gitUserName",
                "",

For these language translation PRs, confirm that:

* The PR was automated (authored by @tiangolo), not made by another user.
* It has the labels `lang-all` and `lang-{lang code}`.

For PRs that update language-specific LLM prompts, confirm that:

* The PR has the labels `lang-all` and `lang-{lang code}`.
* It is approved by at least one native speaker.

1. Once the security report is received one member of the security team tries to verify and reproduce
   the issue and determines the impact it has.
2. A member of the security team will respond and either confirm or reject the security report.
   If the report is rejected the response explains why.
3. Code is audited to find any potential similar problems.
4. Fixes are prepared for the latest release.

    serverListener.assertClosing(1000, "goodbye")

    // Confirm that the hard cancel occurred after 500 ms.
    clientListener.assertFailure()
    val elapsedUntilFailure = System.nanoTime() - closeAtNanos
    assertThat(TimeUnit.NANOSECONDS.toMillis(elapsedUntilFailure).toDouble())
      .isCloseTo(500.0, 250.0)

    // Close the server and confirm it saw what we expected.
    server.close(1000, null)

labels.protwordsFile=Protwords File
labels.kuromojiFile=Kuromoji File
labels.elevateWordFile=Elevate Word File
labels.badWordFile=Bad Word File
labels.urlExpr=Condition
labels.boostExpr=Boost Expression
labels.confirmPassword=Confirm
labels.crawler=Crawler
labels.crudMode=Mode
labels.errorCountMax=Max Error Count
labels.errorCountMin=Min Error Count
labels.facet=Facet
labels.geo=Geo
labels.groups=Groups
labels.hash=Hash

  private val forbiddenLocks = mutableSetOf<Any>()

  /** The timestamp of the last taken event, used to measure elapsed time between events. */
  private var lastTimestampNs: Long? = null

  /** Confirm that the thread does not hold a lock on `lock` during the callback. */
  fun forbidLock(lock: Any) {
    forbiddenLocks.add(lock)
  }

  /**

import okhttp3.internal.http.RecordingProxySelector
import okhttp3.tls.HandshakeCertificates
import okhttp3.tls.internal.TlsUtil.localhost

/**
 * OkHttp is usually tested with functional tests: these use public APIs to confirm behavior against
 * MockWebServer. In cases where logic is particularly tricky, we use unit tests. This class makes
 * it easy to get sample values to use in such tests.
 *

 * is a thin wrapper around {@link InetAddresses} and {@link InternetDomainName}; the unit tests for
 * those classes explore numerous corner cases. The intent here is to confirm that everything is
 * wired up properly.
 *
 * @author Craig Berry
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public final class HostSpecifierTest extends TestCase {