// MockitoExtension handles this automatically for @Mock fields, but good to be aware.
    }

    @Test
    void testIsReceived() {
        // Test initial state (should be false by default for a fresh mock)
        assertFalse(mockResponse.isReceived());

        // Simulate received status
        when(mockResponse.isReceived()).thenReturn(true);
        assertTrue(mockResponse.isReceived());

            this.lastAccessTime = createTime;
            this.leaseKey = leaseKey;
            this.reconnecting = false;
        }
        
        public boolean isExpired() {
            if (type == HandleType.PERSISTENT) {
                return false;  // Persistent handles don't expire
            }
            long elapsed = System.currentTimeMillis() - lastAccessTime;

#
# Specification:
# map:{
#     ; serviceName = [your service name]
#     ; domainPackage = [package]
#     ; environmentList = list:{ [environment name] }
#     ; isMakeActionHtml = [true or false]
#     ; commonMap = map:{
#         ; path = [relative path to common project from DBFlute client]
#         ; freeGenList = list:{ [env or config or label or message or html] }

              }
              return false;
            }

            if (map.valueEquivalence().equivalent(oldValue, entryValue)) {
              ++modCount;
              setValue(e, newValue);
              return true;
            } else {
              // Mimic
              // "if (map.containsKey(key) && map.get(key).equals(oldValue))..."
              return false;
            }
          }

        assertEquals(Boolean.TRUE, DocumentUtil.getValue(doc, "boolTrue", Boolean.class));

        doc.put("boolFalse", false);
        assertEquals(Boolean.FALSE, DocumentUtil.getValue(doc, "boolFalse", Boolean.class));

        doc.put("boolStr", "anything");
        assertEquals(Boolean.FALSE, DocumentUtil.getValue(doc, "boolStr", Boolean.class));
    }

    public void test_unsupported_type_conversion() {

        #    o tableTargetList: (NotRequired - Default list:{})
        #    o columnExceptMap: (NotRequired - Default map:{})
        #    o isSuppressCommonColumn: (NotRequired - Default false)
        #    o isSuppressProcedure: (NotRequired - Default false)
        #
        #; additionalSchemaMap = map:{
        #    ; NEXTEXAMPLEDB = map:{
        #        ; objectTypeTargetList=list:{TABLE ; VIEW}

}

func resetCompressEncryption() {
	// Reset...
	globalCompressConfigMu.Lock()
	globalCompressConfig.Enabled = false
	globalCompressConfig.AllowEncrypted = false
	globalCompressConfigMu.Unlock()
	globalAutoEncryption = false
	GlobalKMS = nil
}

func execExtended(t *testing.T, fn func(t *testing.T, init func(), bucketOptions MakeBucketOptions)) {
	// Exec with default settings...
	resetCompressEncryption()

  @Override
  public boolean contains(@Nullable Object object) {
    if (object == null) {
      return false;
    }
    try {
      @SuppressWarnings("unchecked") // The worst case is usually CCE, which we catch.
      C c = (C) object;
      return range.contains(c);
    } catch (ClassCastException e) {
      return false;
    }
  }

  @Override
  public boolean containsAll(Collection<?> targets) {

    private final CountDownLatch stopLatch = new CountDownLatch(1);

    private volatile boolean running = false;

    @Override
    public @Nullable Void call() throws InterruptedException {
      running = true;
      startLatch.countDown();
      stopLatch.await();
      running = false;
      return null;
    }

    void waitForStart() throws InterruptedException {
      startLatch.await();

    private final AtomicLong totalLeaks = new AtomicLong();

    private final ScheduledExecutorService cleanupExecutor;
    private ScheduledFuture<?> cleanupTask;
    private volatile boolean shutdownInProgress = false;

    // Configuration
    private long maxResourceAge = TimeUnit.HOURS.toMillis(1); // 1 hour default
    private long cleanupInterval = TimeUnit.MINUTES.toMillis(5); // 5 minutes default