assumeNetwork()

    val request = Request("https://www.google.com/robots.txt".toHttpUrl())

    val networkRequest =
      request
        .newBuilder()
        .build()

    val call = client.newCall(networkRequest)

    call.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNull()
    }

    val cachedCall = client.newCall(request)

   * timeout. Because networks can fail during an exchange, it is possible that the remote server
   * accepted the request before the failure.
   */
  fun onFailure(
    call: Call,
    e: IOException,
  )

  /**
   * Called when the HTTP response was successfully returned by the remote server. The callback may

        .sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager())
        .build();

    Call call = client.newCall(new Request.Builder()
        .url(server.url("/"))
        .build());
    Response response = call.execute();
    System.out.println(response.handshake().tlsVersion());
  }

  public static void main(String... args) throws Exception {

            rpc.retval = 0;
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcSamrCloseHandle.class));

        // First close call
        handle.close();

        // Act
        // Second close call
        handle.close();

        // Assert
        // sendrecv for open is called once
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcSamrOpenDomain.class));

    void testIsEstablishedShortCircuit() {
        SpnegoContext ctx = newContext();
        // The mock setup is unnecessary since we never call it
        assertFalse(ctx.isEstablished());
        verify(this.mechContext, never()).isEstablished();
    }

    @Test
    @DisplayName("getNetbiosName returns null and does not call delegate")
    void testGetNetbiosName() {

            int testValue = 123;
            NdrShort ndrShort = new NdrShort(testValue);

            // When: Encoding the value
            ndrShort.encode(mockBuffer);

            // Then: Should call enc_ndr_short with masked value
            verify(mockBuffer).enc_ndr_short(testValue & 0xFF);
            verifyNoMoreInteractions(mockBuffer);
        }

        @Test

    void testNextElementFirstCall() {
        Object element = transaction.nextElement();
        assertSame(transaction, element, "First nextElement should return the transaction itself");
    }

    @Test
    @DisplayName("Test nextElement() changes command on second call")
    void testNextElementSecondCall() {
        // First call - primary
        transaction.nextElement();

		// of such a bucket. This is needed here as we identify such
		// buckets here while listing buckets. As part of regular
		// globalBucketMetadataSys.Init() call would get a valid
		// buckets only and not the quourum lost ones like this, so
		// explicit call
		for bktName, count := range bucketsMap {
			if count < quorum {
				// Queue a bucket heal task
				globalMRFState.addPartialOp(PartialOperation{

        private final RequestOptionCall<BulkRequestBuilder> call;

        private final RequestOptionCall<B> entityCall;

        public BulkList(final List<E> parent, final RequestOptionCall<BulkRequestBuilder> call, final RequestOptionCall<B> entityCall) {
            this.parent = parent;
            this.entityCall = entityCall;
            this.call = call;
        }

        public int size() {

   * trailers are available to read.
   *
   * It is not safe to call this concurrently with code that is processing the response body. If you
   * call this without consuming the complete response body, any remaining bytes in the response
   * body will be discarded before trailers are returned.
   *
   * If [Call.cancel] is called while this is blocking, this call will immediately throw.
   *