}

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

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

            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

          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 =

    void getRemoteHostNameHappyPath() {
        // Ensures remote host name is sourced from transport and resources are closed
        when(transport.getRemoteHostName()).thenReturn("remote.example");
        String name = handle.getRemoteHostName();
        assertEquals("remote.example", name);
        // try-with-resources should close both
        verify(session).close();

    this.isNullOrEmpty() -> emptyList()
    this.size == 1 -> Collections.singletonList(this[0])
    else -> this.clone().asList().unmodifiable()
  }

/** Closes this, ignoring any checked exceptions. */
internal fun Socket.closeQuietly() {
  try {
    close()
  } catch (e: AssertionError) {
    throw e
  } catch (rethrown: RuntimeException) {
    if (rethrown.message == "bio == null") {

            @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 =

    checkNotClosed();
    if (target instanceof Flushable) {
      ((Flushable) target).flush();
    }
  }

  @Override
  public void close() throws IOException {
    this.closed = true;
    if (target instanceof Closeable) {
      ((Closeable) target).close();
    }
  }

  @Override
  public Writer append(char c) throws IOException {
    checkNotClosed();
    target.append(c);
    return this;

        else -> throw EOFException() // We ran out of data before we found the required boundary.
      }
    }

    @Throws(IOException::class)
    override fun close() {
      if (closed) return
      closed = true
      currentPart = null
      source.close()
    }

    /** A single part in a multipart body. */
    class Part(
      @get:JvmName("headers") val headers: Headers,

        } finally {
            CloseableUtil.close(os);
        }
    }

    // ////////////////////////////////////////////////////////////////
    // from InputStream to StringBuilder
    //
    /**
     * Copies from an input stream to a {@link StringBuilder} using the platform default encoding.
     * <p>
     * The input stream is not closed.
     * </p>
     *

    @DisplayName("available() on SMB1 returns 0 and marks closed on disconnected statuses")
    void available_smb1_disconnectedStatuses(int status) throws Exception {
        // Verify SMB1 path: disconnected/server-closed statuses yield 0 and mark fd closed
        SmbPipeInputStream stream = newStreamWithInit(false);

        when(handle.ensureOpen()).thenReturn(fd);