}

        @Test
        @DisplayName("Should handle close operation")
        void testClose() throws IOException {
            // When: Closing handle
            handle.close();

            // Then: Should complete without errors
            assertDoesNotThrow(() -> handle.close());
        }

        @Test
        @DisplayName("Should return string representation")

    code: Int,
    reason: String,
  ) {
  }

  /**
   * Invoked when a web socket has been closed due to an error reading from or writing to the
   * network. Both outgoing and incoming messages may have been lost. No further calls to this
   * listener will be made.
   */
  open fun onFailure(
    webSocket: WebSocket,
    t: Throwable,
    response: Response?,
  ) {
  }

	args += "; echo -n " + exitStr + "$?"

	cmd := adbCmd("exec-out", args)
	cmd.Stdout = filter
	// If the adb subprocess somehow hangs, go test will kill this wrapper
	// and wait for our os.Stderr (and os.Stdout) to close as a result.
	// However, if the os.Stderr (or os.Stdout) file descriptors are
	// passed on, the hanging adb subprocess will hold them open and
	// go test will hang forever.
	//

     * with it.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override
    public void close() throws IOException {
        try {
            if (this.handle.isValid()) {
                this.handle.close();
            }
        } finally {
            this.file.clearAttributeCache();
            this.tmp = null;
        }
    }

    /**

				t.Fatalf("unable to write previously parsed header: %s", err)
			}
			if _, err := ww.Write(f.content); err != nil {
				t.Fatalf("unable to write previously parsed content: %s", err)
			}
		}

		if err := w.Close(); err != nil {
			t.Fatalf("Unable to write archive: %s", err)
		}

		// TODO: We may want to check if the archive roundtrips.
	})

            assertThrows(RuntimeCIFSException.class, transport::release);
        }

        @Test
        @DisplayName("close should call release")
        void shouldCallReleaseOnClose() {
            long initialUsage = transport.getUsageCount();
            transport.close();
            assertEquals(initialUsage - 1, transport.getUsageCount());
        }
    }

    @Nested

     * </p>
     *
     * @param handler the handler to process resources
     */
    void forEach(ResourceHandler handler);

    /**
     * Performs post-processing of resources.
     */
    void close();

          println("failed: $e")
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          println("response: ${response.code}")
          response.close()
        }
      },
    )
  }

      | * WebSocketListener
      |(It is safe to call contentType() and contentLength() on these response bodies.)
      """.trimMargin(),
    )

  override fun timeout() = Timeout.NONE

  override fun close() {
  }
}

fun Response.stripBody(): Response =
  newBuilder()
    .body(UnreadableResponseBody(body.contentType(), body.contentLength()))

      .assertSuccessful()
      .assertCode(200)

    println("server1.requestCount ${server1.requestCount}")
    assertThat(server1.requestCount).isEqualTo(1)

    // Close the proxy server
    if (cleanClose) {
      server1.close()
    }

    // Now redirect with DNS to proxyServer2
    // Then redirect socket connection to server2
    dns["myproxy"] = listOf(proxyServer2)