oxcache 0.5.0-rc.7

#![allow(clippy::module_inception)]
#[allow(unused_imports)]
pub use super::*;

#[cfg(all(test, any(feature = "testing", feature = "memory")))]
mod tests {
    use super::*;
    use crate::testing::MockBackend;

    #[tokio::test]
    async fn test_mock_backend() {
        let backend = MockBackend::new("mock", 50, false);

        // Test set and get
        backend
            .set(Arc::from("key1"), Arc::new(b"value1".to_vec()), None)
            .await
            .unwrap();
        let value = backend.get("key1").await.unwrap();
        assert_eq!(value, Some(b"value1".to_vec()));

        // Test exists
        assert!(backend.exists("key1").await.unwrap());
        assert!(!backend.exists("key2").await.unwrap());

        // Test delete
        backend.delete("key1").await.unwrap();
        assert!(!backend.exists("key1").await.unwrap());

        // Test health check
        backend.health_check().await.unwrap();

        // Test stats
        let stats = backend.stats().await.unwrap();
        assert_eq!(stats.get("type"), Some(&"mock".to_string()));
    }

    #[tokio::test]
    async fn test_isp_traits() {
        let backend = MockBackend::new("mock", 50, false);

        // Test CacheReader trait object
        let reader: &dyn CacheReader = &backend;
        assert!(reader.get("nonexistent").await.unwrap().is_none());

        // Test CacheWriter trait object
        let writer: &dyn CacheWriter = &backend;
        writer
            .set(Arc::from("key"), Arc::new(b"value".to_vec()), None)
            .await
            .unwrap();

        // Test CacheConnector trait object
        let connector: &dyn CacheConnector = &backend;
        connector.health_check().await.unwrap();
        assert_eq!(connector.backend_kind(), BackendKind::Mock);
    }

    // ============================================================================
    // BackendKind 方法测试 (lines 41-42, 46-47)
    // ============================================================================

    #[test]
    fn test_backend_kind_is_memory_moka() {
        assert!(BackendKind::Moka.is_memory());
    }

    #[test]
    fn test_backend_kind_is_memory_dashmap() {
        assert!(BackendKind::DashMap.is_memory());
    }

    #[test]
    fn test_backend_kind_is_memory_mock() {
        assert!(BackendKind::Mock.is_memory());
    }

    #[test]
    fn test_backend_kind_is_memory_redis_false() {
        assert!(!BackendKind::Redis.is_memory());
    }

    #[test]
    fn test_backend_kind_is_memory_chain_false() {
        assert!(!BackendKind::Chain.is_memory());
    }

    #[test]
    fn test_backend_kind_is_memory_unknown_false() {
        assert!(!BackendKind::Unknown.is_memory());
    }

    #[test]
    fn test_backend_kind_is_distributed_redis() {
        assert!(BackendKind::Redis.is_distributed());
    }

    #[test]
    fn test_backend_kind_is_distributed_moka_false() {
        assert!(!BackendKind::Moka.is_distributed());
    }

    #[test]
    fn test_backend_kind_is_distributed_dashmap_false() {
        assert!(!BackendKind::DashMap.is_distributed());
    }

    #[test]
    fn test_backend_kind_is_distributed_chain_false() {
        assert!(!BackendKind::Chain.is_distributed());
    }

    #[test]
    fn test_backend_kind_is_distributed_mock_false() {
        assert!(!BackendKind::Mock.is_distributed());
    }

    #[test]
    fn test_backend_kind_is_distributed_unknown_false() {
        assert!(!BackendKind::Unknown.is_distributed());
    }

    // ============================================================================
    // BackendKind Debug, Clone, PartialEq 测试
    // ============================================================================

    #[test]
    fn test_backend_kind_debug() {
        let kind = BackendKind::Moka;
        let debug_str = format!("{:?}", kind);
        assert!(debug_str.contains("Moka"));
    }

    #[test]
    fn test_backend_kind_clone() {
        let kind = BackendKind::Redis;
        let cloned = kind;
        assert_eq!(kind, cloned);
    }

    #[test]
    fn test_backend_kind_equality() {
        assert_eq!(BackendKind::Moka, BackendKind::Moka);
        assert_ne!(BackendKind::Moka, BackendKind::Redis);
    }

    // ============================================================================
    // CacheReader is_empty 默认方法测试 (lines 82-83)
    // ============================================================================

    #[tokio::test]
    async fn test_cache_reader_is_empty_default() {
        let backend = MockBackend::new("mock", 50, false);
        let reader: &dyn CacheReader = &backend;
        // 空缓存应该返回 true
        assert!(reader.is_empty().await.unwrap());

        // 添加数据后应该返回 false
        backend
            .set(Arc::from("key1"), Arc::new(b"value1".to_vec()), None)
            .await
            .unwrap();
        assert!(!reader.is_empty().await.unwrap());
    }

    // ============================================================================
    // CacheReader get_many 默认方法测试
    // ============================================================================

    #[tokio::test]
    async fn test_cache_reader_get_many_default() {
        let backend = MockBackend::new("mock", 50, false);
        backend
            .set(Arc::from("key1"), Arc::new(b"value1".to_vec()), None)
            .await
            .unwrap();
        backend
            .set(Arc::from("key2"), Arc::new(b"value2".to_vec()), None)
            .await
            .unwrap();

        let reader: &dyn CacheReader = &backend;
        let keys = vec!["key1".to_string(), "key2".to_string(), "key3".to_string()];
        let results = reader.get_many(&keys).await.unwrap();
        assert_eq!(results.len(), 3);
        assert_eq!(results[0], Some(b"value1".to_vec()));
        assert_eq!(results[1], Some(b"value2".to_vec()));
        assert_eq!(results[2], None);
    }

    #[tokio::test]
    async fn test_cache_reader_get_many_empty() {
        let backend = MockBackend::new("mock", 50, false);
        let reader: &dyn CacheReader = &backend;
        let keys: Vec<String> = vec![];
        let results = reader.get_many(&keys).await.unwrap();
        assert!(results.is_empty());
    }

    // ============================================================================
    // CacheWriter set_many 和 delete_many 默认方法测试
    // ============================================================================

    #[tokio::test]
    async fn test_cache_writer_set_many_default() {
        let backend = MockBackend::new("mock", 50, false);
        let writer: &dyn CacheWriter = &backend;
        let items = vec![
            (Arc::from("key1"), Arc::new(b"value1".to_vec()), None),
            (Arc::from("key2"), Arc::new(b"value2".to_vec()), None),
        ];
        writer.set_many(&items).await.unwrap();

        assert!(backend.exists("key1").await.unwrap());
        assert!(backend.exists("key2").await.unwrap());
    }

    #[tokio::test]
    async fn test_cache_writer_delete_many_default() {
        let backend = MockBackend::new("mock", 50, false);
        backend
            .set(Arc::from("key1"), Arc::new(b"value1".to_vec()), None)
            .await
            .unwrap();
        backend
            .set(Arc::from("key2"), Arc::new(b"value2".to_vec()), None)
            .await
            .unwrap();

        let writer: &dyn CacheWriter = &backend;
        let keys = vec!["key1".to_string(), "key2".to_string()];
        writer.delete_many(&keys).await.unwrap();

        assert!(!backend.exists("key1").await.unwrap());
        assert!(!backend.exists("key2").await.unwrap());
    }

    // ============================================================================
    // CacheConnector backend_kind 测试
    // ============================================================================

    #[tokio::test]
    async fn test_cache_connector_backend_kind_mock() {
        let backend = MockBackend::new("mock", 50, false);
        let connector: &dyn CacheConnector = &backend;
        assert_eq!(connector.backend_kind(), BackendKind::Mock);
    }

    #[tokio::test]
    async fn test_cache_connector_shutdown() {
        let backend = MockBackend::new("mock", 50, false);
        let connector: &dyn CacheConnector = &backend;
        // shutdown 不应 panic
        connector.shutdown().await;
    }

    // ============================================================================
    // CacheBackend blanket impl 测试
    // ============================================================================

    #[tokio::test]
    async fn test_cache_backend_trait_object() {
        let backend = MockBackend::new("mock", 50, false);
        let backend_dyn: &dyn CacheBackend = &backend;
        // 测试 CacheBackend 可以作为 trait 对象使用
        backend_dyn
            .set(Arc::from("key"), Arc::new(b"value".to_vec()), None)
            .await
            .unwrap();
        let value = backend_dyn.get("key").await.unwrap();
        assert_eq!(value, Some(b"value".to_vec()));
    }

    // ============================================================================
    // SyncCacheBackend trait hierarchy 测试
    // ============================================================================

    use std::collections::HashMap;
    use std::sync::{Arc, RwLock};
    use std::time::Instant;

    /// 单条 Mock 缓存条目：(value, expires_at)，`None` 表示永不过期。
    type MockSyncEntry = (Vec<u8>, Option<Instant>);

    /// Test mock for sync trait hierarchy. Stores entries with optional TTL
    /// via `Instant`, mirroring `MockBackend` semantics but without async.
    struct MockSyncBackend {
        data: Arc<RwLock<HashMap<String, MockSyncEntry>>>,
        capacity: u64,
    }

    impl MockSyncBackend {
        fn new(capacity: u64) -> Self {
            Self {
                data: Arc::new(RwLock::new(HashMap::new())),
                capacity,
            }
        }
    }

    impl SyncCacheReader for MockSyncBackend {
        fn get(&self, key: &str) -> OxCacheResult<Option<Vec<u8>>> {
            let data = self.data.read().unwrap();
            if let Some((value, expires_at)) = data.get(key) {
                if let Some(deadline) = expires_at
                    && *deadline <= Instant::now()
                {
                    return Ok(None);
                }
                return Ok(Some(value.clone()));
            }
            Ok(None)
        }

        fn exists(&self, key: &str) -> OxCacheResult<bool> {
            Ok(self.get(key)?.is_some())
        }

        fn ttl(&self, key: &str) -> OxCacheResult<Option<Duration>> {
            let data = self.data.read().unwrap();
            if let Some((_, Some(deadline))) = data.get(key) {
                return Ok(deadline.checked_duration_since(Instant::now()));
            }
            Ok(None)
        }

        fn len(&self) -> OxCacheResult<u64> {
            Ok(self.data.read().unwrap().len() as u64)
        }

        fn capacity(&self) -> OxCacheResult<u64> {
            Ok(self.capacity)
        }

        fn stats(&self) -> OxCacheResult<HashMap<String, String>> {
            let mut stats = HashMap::new();
            stats.insert("type".to_string(), "mock_sync".to_string());
            stats.insert("len".to_string(), self.len()?.to_string());
            Ok(stats)
        }
    }

    impl SyncCacheWriter for MockSyncBackend {
        fn set(
            &self,
            key: Arc<str>,
            value: Arc<Vec<u8>>,
            ttl: Option<Duration>,
        ) -> OxCacheResult<()> {
            let expires_at = ttl.map(|d| Instant::now() + d);
            self.data
                .write()
                .unwrap()
                .insert(key.to_string(), ((*value).clone(), expires_at));
            Ok(())
        }

        fn delete(&self, key: &str) -> OxCacheResult<()> {
            self.data.write().unwrap().remove(key);
            Ok(())
        }

        fn clear(&self) -> OxCacheResult<()> {
            self.data.write().unwrap().clear();
            Ok(())
        }

        fn expire(&self, key: &str, ttl: Duration) -> OxCacheResult<bool> {
            let mut data = self.data.write().unwrap();
            if let Some(entry) = data.get_mut(key) {
                entry.1 = Some(Instant::now() + ttl);
                return Ok(true);
            }
            Ok(false)
        }
    }

    impl SyncCacheConnector for MockSyncBackend {
        fn health_check(&self) -> OxCacheResult<()> {
            Ok(())
        }

        fn shutdown(&self) {
            self.clear().ok();
        }

        fn backend_kind(&self) -> BackendKind {
            BackendKind::Mock
        }
    }

    #[test]
    fn test_sync_cache_backend_trait_object_usable() {
        let backend = MockSyncBackend::new(50);
        let backend_dyn: &dyn SyncCacheBackend = &backend;

        // 写入 + 读取
        backend_dyn
            .set(Arc::from("key1"), Arc::new(b"value1".to_vec()), None)
            .unwrap();
        let value = backend_dyn.get("key1").unwrap();
        assert_eq!(value, Some(b"value1".to_vec()));

        // exists
        assert!(backend_dyn.exists("key1").unwrap());
        assert!(!backend_dyn.exists("missing").unwrap());

        // delete
        backend_dyn.delete("key1").unwrap();
        assert!(!backend_dyn.exists("key1").unwrap());

        // connector
        backend_dyn.health_check().unwrap();
        assert_eq!(backend_dyn.backend_kind(), BackendKind::Mock);
    }

    #[test]
    fn test_sync_reader_default_is_empty_uses_len() {
        let backend = MockSyncBackend::new(50);
        let reader: &dyn SyncCacheReader = &backend;
        // 空缓存
        assert!(reader.is_empty().unwrap());
        // 添加数据后
        backend
            .set(Arc::from("k"), Arc::new(b"v".to_vec()), None)
            .unwrap();
        assert!(!reader.is_empty().unwrap());
    }

    #[test]
    fn test_sync_writer_default_set_many_loops_set() {
        let backend = MockSyncBackend::new(50);
        let writer: &dyn SyncCacheWriter = &backend;
        let items = vec![
            (Arc::from("k1"), Arc::new(b"v1".to_vec()), None),
            (Arc::from("k2"), Arc::new(b"v2".to_vec()), None),
            (Arc::from("k3"), Arc::new(b"v3".to_vec()), None),
        ];
        writer.set_many(&items).unwrap();

        assert_eq!(backend.get("k1").unwrap(), Some(b"v1".to_vec()));
        assert_eq!(backend.get("k2").unwrap(), Some(b"v2".to_vec()));
        assert_eq!(backend.get("k3").unwrap(), Some(b"v3".to_vec()));
        assert_eq!(backend.len().unwrap(), 3);

        // delete_many 默认实现
        writer
            .delete_many(&["k1".to_string(), "k2".to_string()])
            .unwrap();
        assert!(!backend.exists("k1").unwrap());
        assert!(!backend.exists("k2").unwrap());
        assert!(backend.exists("k3").unwrap());
    }

    #[test]
    fn test_sync_reader_default_get_many_loops_get() {
        let backend = MockSyncBackend::new(50);
        backend
            .set(Arc::from("k1"), Arc::new(b"v1".to_vec()), None)
            .unwrap();
        backend
            .set(Arc::from("k2"), Arc::new(b"v2".to_vec()), None)
            .unwrap();

        let reader: &dyn SyncCacheReader = &backend;
        let keys = vec!["k1".to_string(), "k2".to_string(), "k3".to_string()];
        let results = reader.get_many(&keys).unwrap();
        assert_eq!(results.len(), 3);
        assert_eq!(results[0], Some(b"v1".to_vec()));
        assert_eq!(results[1], Some(b"v2".to_vec()));
        assert_eq!(results[2], None);
    }

    #[test]
    fn test_sync_backend_ttl_and_expire() {
        let backend = MockSyncBackend::new(50);
        backend
            .set(
                Arc::from("k"),
                Arc::new(b"v".to_vec()),
                Some(Duration::from_secs(60)),
            )
            .unwrap();

        // ttl 返回剩余时间
        let ttl = backend.ttl("k").unwrap();
        assert!(ttl.is_some());
        let ttl = ttl.unwrap();
        assert!(ttl <= Duration::from_secs(60) && ttl > Duration::from_secs(58));

        // expire 返回 true（key 存在）
        let result = backend.expire("k", Duration::from_secs(120)).unwrap();
        assert!(result);
        let new_ttl = backend.ttl("k").unwrap().unwrap();
        assert!(new_ttl > Duration::from_secs(118));

        // expire 返回 false（key 不存在）
        let result = backend.expire("missing", Duration::from_secs(10)).unwrap();
        assert!(!result);
    }

    // ============================================================================
    // BackendKind::is_composite 测试
    // ============================================================================

    #[test]
    fn test_backend_kind_is_composite_chain() {
        assert!(BackendKind::Chain.is_composite());
    }

    #[test]
    fn test_backend_kind_is_composite_others_false() {
        assert!(!BackendKind::Moka.is_composite());
        assert!(!BackendKind::DashMap.is_composite());
        assert!(!BackendKind::Redis.is_composite());
        assert!(!BackendKind::Mock.is_composite());
        assert!(!BackendKind::Unknown.is_composite());
        // New variants
        assert!(!BackendKind::Valkey.is_composite());
        assert!(!BackendKind::Dragonfly.is_composite());
        assert!(!BackendKind::Aerospike.is_composite());
    }

    // ============================================================================
    // BackendKind 新后端变体测试
    // ============================================================================

    #[test]
    fn test_backend_kind_is_distributed_valkey() {
        assert!(BackendKind::Valkey.is_distributed());
    }

    #[test]
    fn test_backend_kind_is_distributed_dragonfly() {
        assert!(BackendKind::Dragonfly.is_distributed());
    }

    #[test]
    fn test_backend_kind_is_distributed_aerospike() {
        assert!(BackendKind::Aerospike.is_distributed());
    }

    #[test]
    fn test_backend_kind_is_memory_valkey_false() {
        assert!(!BackendKind::Valkey.is_memory());
    }

    #[test]
    fn test_backend_kind_is_memory_dragonfly_false() {
        assert!(!BackendKind::Dragonfly.is_memory());
    }

    #[test]
    fn test_backend_kind_is_memory_aerospike_false() {
        assert!(!BackendKind::Aerospike.is_memory());
    }

    #[test]
    fn test_backend_kind_is_composite_valkey_false() {
        assert!(!BackendKind::Valkey.is_composite());
    }

    #[test]
    fn test_backend_kind_is_composite_dragonfly_false() {
        assert!(!BackendKind::Dragonfly.is_composite());
    }

    #[test]
    fn test_backend_kind_is_composite_aerospike_false() {
        assert!(!BackendKind::Aerospike.is_composite());
    }

    #[test]
    fn test_backend_kind_new_variants_debug_clone_eq() {
        // Debug
        assert!(format!("{:?}", BackendKind::Valkey).contains("Valkey"));
        assert!(format!("{:?}", BackendKind::Dragonfly).contains("Dragonfly"));
        assert!(format!("{:?}", BackendKind::Aerospike).contains("Aerospike"));
        // Clone + Eq
        assert_eq!(BackendKind::Valkey, BackendKind::Valkey);
        assert_eq!(BackendKind::Dragonfly, BackendKind::Dragonfly);
        assert_eq!(BackendKind::Aerospike, BackendKind::Aerospike);
        assert_ne!(BackendKind::Valkey, BackendKind::Redis);
        assert_ne!(BackendKind::Dragonfly, BackendKind::Valkey);
    }

    // ============================================================================
    // CacheReader::keys 默认实现测试
    // ============================================================================

    #[tokio::test]
    async fn test_cache_reader_keys_default_returns_empty() {
        let backend = MockBackend::new("mock", 50, false);
        let reader: &dyn CacheReader = &backend;
        // MockBackend 覆盖了 keys()，但默认实现通过 trait object 测试
        // 使用 CacheReader trait 的默认实现
        let keys = reader.keys("*").await.unwrap();
        // MockBackend 的 keys 返回匹配的 key，空缓存应返回空
        assert!(keys.is_empty());
    }

    // ============================================================================
    // SyncCacheReader::keys 默认实现测试
    // ============================================================================

    #[test]
    fn test_sync_reader_keys_default_returns_empty() {
        let backend = MockSyncBackend::new(50);
        let reader: &dyn SyncCacheReader = &backend;
        // MockSyncBackend 没有覆盖 keys()，使用默认实现
        let keys = reader.keys("*").unwrap();
        assert!(keys.is_empty());
    }

    // ============================================================================
    // CacheConnector 默认方法测试
    // ============================================================================

    #[tokio::test]
    async fn test_cache_connector_as_atomic_writer_default_none() {
        let backend = MockBackend::new("mock", 50, false);
        let connector: &dyn CacheConnector = &backend;
        // MockBackend 覆盖了 as_atomic_writer 返回 Some
        assert!(connector.as_atomic_writer().is_some());
    }

    #[tokio::test]
    async fn test_cache_connector_as_atomic_writer_dashmap_none() {
        use crate::backend::DashMapMemoryBackend;
        let backend = DashMapMemoryBackend::new();
        let connector: &dyn CacheConnector = &backend;
        // DashMap 不实现 AtomicCacheWriter，默认返回 None
        assert!(connector.as_atomic_writer().is_none());
    }

    // ============================================================================
    // glob_match unit tests
    // ============================================================================

    #[test]
    fn test_glob_match_exact_match() {
        assert!(glob_match("hello", "hello"));
        assert!(!glob_match("hello", "world"));
        assert!(!glob_match("hello", "hell"));
        assert!(!glob_match("hell", "hello"));
    }

    #[test]
    fn test_glob_match_star_matches_any() {
        assert!(glob_match("*", ""));
        assert!(glob_match("*", "anything"));
        assert!(glob_match("hello*", "hello"));
        assert!(glob_match("hello*", "helloworld"));
        assert!(glob_match("*world", "helloworld"));
        assert!(glob_match("he*ld", "helloworld"));
        assert!(!glob_match("he*ld", "hello"));
        // 尾星跨 / 匹配
        assert!(glob_match("prefix*", "prefix/with/slash"));
    }

    #[test]
    fn test_glob_match_question_mark() {
        assert!(glob_match("h?llo", "hello"));
        assert!(glob_match("?????", "hello"));
        assert!(!glob_match("????", "hello"));
        assert!(!glob_match("??????", "hello"));
        assert!(glob_match("h?llo", "hallo"));
        assert!(!glob_match("?", ""));
    }

    #[test]
    fn test_glob_match_combined_patterns() {
        assert!(glob_match("h*o", "hello"));
        assert!(glob_match("h*o", "ho"));
        assert!(glob_match("h?l*w", "hellow"));
        assert!(glob_match("*?*", "a"));
        assert!(!glob_match("*?*", ""));
        assert!(glob_match("a*b*c", "abc"));
        assert!(glob_match("a*b*c", "aXbYc"));
        assert!(!glob_match("a*b*c", "aXbY"));
    }

    #[test]
    fn test_glob_match_empty() {
        assert!(glob_match("", ""));
        assert!(!glob_match("", "a"));
        assert!(glob_match("*", ""));
    }

    #[test]
    fn test_glob_match_star_matches_slash() {
        assert!(glob_match("cache/*", "cache/item"));
        assert!(glob_match("*/*", "a/b"));
        assert!(glob_match("a*b*c", "a/b/c"));
        assert!(glob_match("a*b*c", "aXbYc"));
        assert!(!glob_match("a*b*c", "aXbY"));
        // 字面斜杠语义钉子：`cache/*` 的 / 必须逐字匹配（无斜杠文本不匹配）
        assert!(!glob_match("cache/*", "cache"));
    }

    // ========================================================================
    // AsyncToSyncBridge —— 诚实探测与原子桥接臂
    // ========================================================================

    /// current_thread runtime 内桥接 shutdown 无法嵌套驱动：跳过并计数
    /// `oxcache_bridge_shutdown_rejected_total`（默认预设可见的拒绝信号）。
    #[tokio::test]
    #[cfg(feature = "metrics")]
    // delta 断言依赖全局计数器窗口期不被清零，须与重置全局指标的串行测试互斥
    #[serial_test::serial]
    async fn bridge_shutdown_inside_current_thread_runtime_counts_rejection() {
        let before = dynamic_counter("oxcache_bridge_shutdown_rejected_total");

        let bridge = AsyncToSyncBridge::new(Arc::new(MockBackend::new("bridge-skip", 50, false)));
        bridge.shutdown();

        assert!(
            dynamic_counter("oxcache_bridge_shutdown_rejected_total") > before,
            "shutdown rejection inside current_thread runtime must be counted"
        );
    }

    /// 读取 unified 动态计数器快照（缺失视为 0）；metrics-only 依赖随唯一
    /// 调用者的 feature 门控同步缺席
    #[cfg(feature = "metrics")]
    fn dynamic_counter(key: &str) -> u64 {
        use crate::infra::metrics::unified::MetricValue;
        crate::infra::metrics::unified::GLOBAL_UNIFIED_METRICS
            .get_dynamic_metrics()
            .get(key)
            .and_then(|v| match v {
                MetricValue::Counter(c) => Some(*c),
                _ => None,
            })
            .unwrap_or(0)
    }

    /// inner 有 async 原子面（MockBackend as_atomic_writer→Some）：桥接广告
    /// 同步原子能力且 incr 真实走通（block_in_place + block_on 阻塞路径）。
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn bridge_advertises_sync_atomic_when_inner_has_async_atomic() {
        let bridge = AsyncToSyncBridge::new(Arc::new(MockBackend::new("bridge-atomic", 50, false)));
        // as_atomic_writer 探测在 dyn 层（&dyn CacheBackend）执行
        assert!(bridge.as_sync_atomic_writer().is_some());

        let writer: &dyn SyncAtomicCacheWriter = bridge.as_sync_atomic_writer().unwrap();
        assert_eq!(writer.incr("bridge:counter", 5, None).unwrap(), 5);
        assert_eq!(writer.incr("bridge:counter", 7, None).unwrap(), 12);
        assert!(
            writer
                .set_if_absent("bridge:cas", b"v".to_vec(), None)
                .unwrap()
        );
        assert!(
            !writer
                .set_if_absent("bridge:cas", b"w".to_vec(), None)
                .unwrap()
        );
        assert!(
            writer
                .compare_and_swap("bridge:cas", Some(b"v"), b"v2".to_vec(), None)
                .unwrap()
        );
    }

    /// inner 无 async 原子面（DashMapMemoryBackend 用默认 as_atomic_writer→None）：
    /// 桥接诚实返回 None，原子方法以 NotSupported 兜底——探测误写为无条件
    /// Some(self) 时本测试显性失败。
    #[cfg(feature = "memory")]
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn bridge_hides_sync_atomic_when_inner_lacks_async_atomic() {
        let dashmap = crate::backend::DashMapMemoryBackend::builder().build();
        let bridge = AsyncToSyncBridge::new(Arc::new(dashmap));

        let connector: &dyn SyncCacheConnector = &bridge;
        assert!(
            connector.as_sync_atomic_writer().is_none(),
            "inner without an async atomic face must not be advertised as sync-atomic"
        );

        // 兜底路径：Cache::incr_sync 的探测链会因 None 而 NotSupported；
        // 此处额外锁 method 级 NotSupported（绕过探测直接调用的防御分支）
        let atomic_bridge: &dyn SyncAtomicCacheWriter = &bridge;
        let err = atomic_bridge.incr("dashmap:counter", 1, None).unwrap_err();
        assert!(
            matches!(err, OxCacheError::NotSupported(_)),
            "atomic fallback must be NotSupported, got {err:?}"
        );
    }

    /// shutdown 在 runtime 之外真实执行（临时 current_thread runtime 兜底）：
    /// 经桥接驱动 inner shutdown 而非静默跳过。
    #[test]
    fn bridge_shutdown_executes_outside_runtime() {
        let bridge =
            AsyncToSyncBridge::new(Arc::new(MockBackend::new("bridge-shutdown", 50, false)));
        // 无返回值可断言：不 panic 即为执行成功（MockBackend shutdown 为 no-op，
        // 本测试锁定的是「不再因缺 runtime 而拒绝」的路径）
        bridge.shutdown();
    }

    /// Cache::incr_sync 端到端经桥接：backend_arc 注入的 async 原子面后端在
    /// sync_mode 下经探针呈现同步原子能力并返回正确结果。
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn cache_incr_sync_end_to_end_via_bridge() {
        let cache = crate::cache::CacheBuilder::<String, i64>::default()
            .backend_arc(Arc::new(MockBackend::new("bridge-e2e", 100, false)))
            .sync_mode(true)
            .build_sync()
            .unwrap();

        let value = cache
            .incr_sync(&"e2e:counter".to_string(), 21, None)
            .unwrap();
        assert_eq!(value, 21);
        let value = cache
            .incr_sync(&"e2e:counter".to_string(), 21, None)
            .unwrap();
        assert_eq!(value, 42);
    }
}