* try (Response response = call.execute()) {
 * ... // Use the response.
 * }
 * ```
 *
 * You can use a similar block for asynchronous calls:
 *
 * ```java
 * Call call = client.newCall(request);
 * call.enqueue(new Callback() {
 *   public void onResponse(Call call, Response response) throws IOException {
 *     try (ResponseBody responseBody = response.body()) {
 *     ... // Use the response.
 *     }
 *   }
 *

Pode ser que você precise comunicar ao cliente que:

* O cliente não tem direitos para realizar aquela operação.
* O cliente não tem acesso aquele recurso.
* O item que o cliente está tentando acessar não existe.
* etc.


Nesses casos, você normalmente retornaria um **HTTP status code** próximo ao status code na faixa do status code **400** (do 400 ao 499).

  }

  @Test
  fun call() {
    val call: Call =
      object : Call {
        override fun request(): Request = TODO()

        override fun execute(): Response = TODO()

        override fun enqueue(responseCallback: Callback) = TODO()

        override fun cancel() = TODO()

        override fun isExecuted(): Boolean = TODO()

        override fun isCanceled(): Boolean = TODO()

    /** Array of supported file protocols for URL classification. */
    protected String[] fileProtocols = { "file:", "smb:", "smb1:", "ftp:", "storage:" };

    /** Queue to track the current XML element hierarchy during parsing. */
    protected LinkedList<String> tagQueue;

    /** List to store parsed label types for access control. */
    protected List<LabelType> labelList;

    waiter1.start();
    waiter1.awaitWaiting();

    WaiterThread waiter2 = new WaiterThread(future);
    waiter2.start();
    waiter2.awaitWaiting();
    // The waiter queue should be waiter2->waiter1

    // This should wake up waiter1 and cause the waiter1 node to be removed.
    waiter1.interrupt();

    waiter1.join();
    waiter2.awaitWaiting(); // should still be blocked

					healOnce.Do(func() {
						globalMRFState.addPartialOp(PartialOperation{
							Bucket:     bucket,
							Object:     object,
							VersionID:  fi.VersionID,
							Queued:     time.Now(),
							SetIndex:   er.setIndex,
							PoolIndex:  er.poolIndex,
							BitrotScan: errors.Is(err, errFileCorrupt),
						})
					})
					// Healing is triggered and we have written

        // Create spies
        SmbTransportImpl pooledSpy = spy(pooled);
        SmbTransportImpl nonPooledSpy = spy(nonPooled);

        // Replace with spies (remove and add back for concurrent queues)
        connections.remove(pooled);
        connections.offer(pooledSpy);
        nonPooledConnections.remove(nonPooled);
        nonPooledConnections.offer(nonPooledSpy);

        // Mock disconnect behavior

//   - Pointer to array: the number of elements in *v (even if v is nil).
//   - Slice, or map: the number of elements in v; if v is nil, len(v) is zero.
//   - String: the number of bytes in v.
//   - Channel: the number of elements queued (unread) in the channel buffer;
//     if v is nil, len(v) is zero.
//
// For some arguments, such as a string literal or a simple array expression, the

    threadPool.shutdown();
    threadPool.awaitTermination(300, SECONDS);

    // Since we're not doing any more cache operations, and the cache only expires/evicts when doing
    // other operations, the cache and the removal queue won't change from this point on.

    // Verify that each received removal notification was valid
    for (RemovalNotification<String, String> notification : removalListener) {

    threadPool.shutdown();
    threadPool.awaitTermination(300, SECONDS);

    // Since we're not doing any more cache operations, and the cache only expires/evicts when doing
    // other operations, the cache and the removal queue won't change from this point on.

    // Verify that each received removal notification was valid
    for (RemovalNotification<String, String> notification : removalListener) {