@Test
  fun delayResponse() {
    assumeNotWindows()
    server.enqueue(
      MockResponse
        .Builder()
        .body("ABCDEF")
        .bodyDelay(1, TimeUnit.SECONDS)
        .build(),
    )
    val startNanos = System.nanoTime()
    val connection = server.url("/").toUrl().openConnection()
    val inputStream = connection!!.getInputStream()

```Python
from app.routers import items, users
```

/// info | Información

La primera versión es un "import relativo":

```Python
from .routers import items, users
```

La segunda versión es un "import absoluto":

```Python
from app.routers import items, users
```

```Python
from app.routers import items, users
```

/// info | Informação

A primeira versão é uma "importação relativa":

```Python
from .routers import items, users
```

A segunda versão é uma "importação absoluta":

```Python
from app.routers import items, users
```

     * Shutdown the audit logger gracefully
     */
    public void shutdown() {
        shutdown = true;
        logExecutor.shutdown();
        try {
            if (!logExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                logExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            logExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    assertThat(response1.body.string()).isEqualTo("abc")
    response1.close()

    // Force a fresh connection for the next request.
    client.connectionPool.evictAll()

    // Confirm that a second request also succeeds. This should detect caching problems.
    server.enqueue(
      MockResponse
        .Builder()
        .body("def")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )

	l.Lock()
	go f()
	l.Lock()
	print(a)
}
</pre>

<p>
is guaranteed to print <code>"hello, world"</code>.
The first call to <code>l.Unlock()</code> (in <code>f</code>) is synchronized
before the second call to <code>l.Lock()</code> (in <code>main</code>) returns,
which is sequenced before the <code>print</code>.
</p>

<p class="rule">

   * equivalent {@link Integer#compareUnsigned(int, int)} method instead.
   *
   * @param a the first unsigned {@code int} to compare
   * @param b the second unsigned {@code int} to compare
   * @return a negative value if {@code a} is less than {@code b}; a positive value if {@code a} is
   *     greater than {@code b}; or zero if they are equal
   */

                execJob.jvmOptions("-Xms" + i + "m");
            }
            latch.countDown();
        });

        t1.start();
        t2.start();

        assertTrue(latch.await(5, TimeUnit.SECONDS));
        // The exact size may vary due to concurrent modifications, just check it's not empty
        assertTrue(execJob.jvmOptions.size() > 0);
    }

    // Test pattern matching in custom properties

  }

  /** For testing: force this web socket to release its threads. */
  @Throws(InterruptedException::class)
  fun tearDown() {
    taskQueue.shutdown()
    taskQueue.idleLatch().await(10, TimeUnit.SECONDS)
  }

  @Synchronized fun sentPingCount(): Int = sentPingCount

  @Synchronized fun receivedPingCount(): Int = receivedPingCount

  @Synchronized fun receivedPongCount(): Int = receivedPongCount

	Mode     fs.FileMode
	NonUTF8  bool
	ModTime  time.Time
	Modified time.Time

	// Information describing expected zip file content.
	// First, reading the entire content should produce the error ContentErr.
	// Second, if ContentErr==nil, the content should match Content.
	// If content is large, an alternative to setting Content is to set File,
	// which names a file in the testdata/ directory containing the
	// uncompressed expected content.