resource.close();
                        holder.closed = true;
                        cleaned++;
                    } catch (Exception e) {
                        log.error("Failed to force close resource: {}", holder.resourceId, e);
                    }
                }
            }
        }

        log.info("Force cleaned {} resources", cleaned);
        return cleaned;
    }

    /**

 *
 * {@snippet :
 * FluentFuture<UserName> userName =
 *     ClosingFuture.submit(
 *             closer -> closer.eventuallyClose(database.newTransaction(), closingExecutor),
 *             executor)
 *         .transformAsync((closer, transaction) -> transaction.queryClosingFuture("..."), executor)
 *         .transform((closer, result) -> result.get("userName"), directExecutor())

    Closer closer = new Closer(suppressor);

    IOException exception = new IOException();

    // c2 is added last, closed first
    TestCloseable c1 = closer.register(TestCloseable.normal());
    TestCloseable c2 = closer.register(TestCloseable.throwsOnClose(exception));

    try {
      closer.close();
    } catch (Throwable expected) {

        }
    }

    /**
     * Check if this context is closed
     *
     * @return true if closed, false otherwise
     */
    public boolean isClosed() {
        return closed;
    }

      if (civilizedFileSystem) return fileSource

      lockingSourceCount++
      return object : ForwardingSource(fileSource) {
        private var closed = false

        override fun close() {
          super.close()
          if (!closed) {
            closed = true
            synchronized(this@DiskLruCache) {
              lockingSourceCount--
              if (lockingSourceCount == 0 && zombie) {

    checkNotNull(sink);

    Closer closer = Closer.create();
    try {
      Reader reader = closer.register(openStream());
      Writer writer = closer.register(sink.openStream());
      return CharStreams.copy(reader, writer);
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  /**

    checkNotNull(sink);

    Closer closer = Closer.create();
    try {
      Reader reader = closer.register(openStream());
      Writer writer = closer.register(sink.openStream());
      return CharStreams.copy(reader, writer);
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  /**

    }
  }

  // Avoid infinite recursion if a closeable's close() method throws RejectedExecutionException and
  // is closed using the direct executor.
  public void testCloseThrowsRejectedExecutionException() throws Exception {
    doThrow(new RejectedExecutionException()).when(mockCloseable).close();
    ClosingFuture<Closeable> closingFuture =
        ClosingFuture.submit(

                testEncryptionKey, testDecryptionKey);

        // When/Then - Multiple closes should be safe
        assertDoesNotThrow(() -> {
            context.close();
            context.close();
            context.close();
        });

        assertTrue(context.isClosed());
    }

    @Test
    @DisplayName("Should handle concurrent operations with SecureKeyManager")

      private var closed = false

      override fun close() {
        if (closed) return
        try {
          super.close()
        } finally {
          closedLatch.countDown()
        }
      }
    }.buffer()

  override val sink: BufferedSink =
    object : ForwardingSink(delegate.sink) {
      private var closed = false

      override fun close() {