@Override
              public Closeable call(DeferredCloser closer) throws Exception {
                return closer.eventuallyClose(mockCloseable, executor);
              }
            },
            executor);
    closingFuture.finishToValueAndCloser(new NoOpValueAndCloserConsumer<>(), directExecutor());
    assertThrows(
        IllegalStateException.class,
        () -> {

        doThrow(expectedException).when(watchHandle).close();

        // Execute and verify
        CIFSException thrown = assertThrows(CIFSException.class, () -> {
            watchHandle.close();
        });

        assertEquals("Failed to close handle", thrown.getMessage());
        verify(watchHandle, times(1)).close();
    }

    /**

	if err != nil {
		t.Fatalf("failed to connect database, got error %v", err)
	}
	rawDB, _ := DB.DB()
	rawDB.Close()

	if err := DB.Transaction(func(tx *gorm.DB) error {
		return nil
	}); err == nil {
		t.Errorf("should returns error when commit with closed conn, got error %v", err)
	}

	if err := DB.Session(&gorm.Session{PrepareStmt: true}).Transaction(func(tx *gorm.DB) error {
		return nil

        verify(mockDelegate).close();
    }

    @Test
    void testClose_False() throws CIFSException {
        // Test close() method when false
        when(mockDelegate.close()).thenReturn(false);
        assertFalse(cifsContextWrapper.close());
        verify(mockDelegate).close();
    }

	w := newMetacacheWriter(&buf, 1<<20)
	defer w.Close()
	err := r.readFn(func(object metaCacheEntry) bool {
		err := w.write(object)
		if err != nil {
			t.Fatal(err)
		}
		return true
	})
	r.Close()
	if err != io.EOF {
		t.Fatal(err)
	}
	err = w.Close()
	if err != nil {
		t.Fatal(err)
	}

	r = newMetacacheReader(&buf)
	defer r.Close()
	names, err := r.readNames(-1)

    assertEquals(Integer.MAX_VALUE, ms.headMultiset("b", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.headMultiset("a", CLOSED).size());

    assertEquals(3, ms.tailMultiset("c", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.tailMultiset("b", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.tailMultiset("a", CLOSED).size());
  }

  @J2ktIncompatible

    out.write(b);
    count++;
  }

  // Overriding close() because FilterOutputStream's close() method pre-JDK8 has bad behavior:
  // it silently ignores any exception thrown by flush(). Instead, just close the delegate stream.
  // It should flush itself if necessary.
  @Override
  public void close() throws IOException {
    out.close();
  }

                            timingRatio, TIMING_TOLERANCE, timeStart, timeMiddle, timeEnd));
        } finally {
            // Clean up resources
            baseAuth.close();
            startAuth.close();
            middleAuth.close();
            endAuth.close();
        }
    }

    /**
     * Test constant-time comparison with various password lengths.
     */
    @Test

        // Test that multiple close() calls are all ignored
        byte[] data = "Test data".getBytes();
        ByteArrayInputStream underlyingStream = new ByteArrayInputStream(data);
        IgnoreCloseInputStream stream = new IgnoreCloseInputStream(underlyingStream);

        // Multiple close calls should all be ignored
        stream.close();
        stream.close();
        stream.close();

   * exists but cannot be used for another exchange, it is closed and this returns null.
   */
  private fun planReuseCallConnection(): ReusePlan? {
    // This may be mutated by releaseConnectionNoEvents()!
    val candidate = call.connection ?: return null

    // Make sure this connection is healthy & eligible for new exchanges. If it's no longer needed
    // then we're on the hook to close it.