return err
	}
	defer gw.Close()

	var wc io.WriteCloser = gzip.NewWriter(gw)
	if _, err = io.Copy(wc, r); err != nil {
		return err
	}

	if err = wc.Close(); err != nil {
		return err
	}

	// Persist to disk any caches.
	if err = gw.Sync(); err != nil {
		return err
	}

	// close everything before we delete.
	if err = gw.Close(); err != nil {
		return err
	}

        }

        @Override
        public void close() throws Exception {
            if (closed) {
                return;
            }

            try {
                resource.close();
            } finally {
                closed = true;
                manager.markClosed(resourceId);
                manager.unregisterResource(resourceId);
            }
        }
    }

        return fileInputStream.available();
    }

    /**
     * Closes this input stream and releases any system resources associated with the stream.
     * @throws IOException if an I/O error occurs.
     */
    @Override
    public void close() throws IOException {
        try {
            fileInputStream.close();
        } finally {
            FileUtil.deleteInBackground(tempFile);
        }
    }

            It will be closed if no further activity occurs. Thank you.
          close-issue-message: >
            This issue was closed because it has been inactive for 7 days since being marked as stale.
            Please reopen if you'd like to work on this further.
          days-before-pr-stale: 14
          days-before-pr-close: 14

	return c.CallWithHTTPMethod(ctx, http.MethodPost, rpcMethod, values, body, length)
}

// Close closes all idle connections of the underlying http client
func (c *Client) Close() {
	atomic.StoreInt32(&c.connected, closed)
}

// NewClient - returns new REST client.
func NewClient(uu *url.URL, tr http.RoundTripper, auth func() string) *Client {
	connected := int32(online)

          val source = Buffer().writeUtf8("hello")
          return object : ForwardingSource(source) {
            override fun close() {
              closed = true
              super.close()
            }
          }.buffer()
        }
      }
    body.source().close()
    assertThat(closed).isTrue()
  }

  @Test
  fun throwingUnderlyingSourceClosesQuietly() {
    val body: ResponseBody =

    }
  }

  /**
   * Closes this connection. This cancels all open streams and unanswered pings. It closes the
   * underlying input and output streams and shuts down internal task queues.
   */
  override fun close() {
    close(ErrorCode.NO_ERROR, ErrorCode.CANCEL, null)
  }

  internal fun close(
    connectionCode: ErrorCode,
    streamCode: ErrorCode,

     *
     * @see jcifs.SmbTransportPool#close()
     */
    @Override
    public boolean close() throws CIFSException {
        boolean inUse = false;

        // Cleanup first
        cleanup();
        log.debug("Closing pool");

        // Create a snapshot of connections to close
        List<SmbTransportImpl> toClose = new ArrayList<>(this.connections);
        toClose.addAll(this.nonPooledConnections);

            try {
                return copyInternal(is, os);
            } finally {
                CloseableUtil.close(os);
            }
        } finally {
            CloseableUtil.close(is);
        }
    }

    /**
     * Copies from a file with the specified encoding to a file with the platform default encoding.
     *

            @Throws(IOException::class)
            override fun close() {
              closed.set(true)
              super.close()
            }
          }.buffer()
        }
      }
    body.charStream().close()
    assertThat(closed.get()).isTrue()
  }

  @Test
  fun readerClosedAfterBomClosesUnderlyingSource() {
    val closed = AtomicBoolean()
    val body: ResponseBody =