Add Debug impl to the following caches

src/future/cache.rs

@@ -20,6 +20,7 @@ use std::{
     any::TypeId,
     borrow::Borrow,
     collections::hash_map::RandomState,
+    fmt,
     future::Future,
     hash::{BuildHasher, Hash},
     sync::Arc,
@@ -314,6 +315,24 @@ impl<K, V, S> Clone for Cache<K, V, S> {
     }
 }
 
+impl<K, V, S> fmt::Debug for Cache<K, V, S>
+where
+    K: fmt::Debug + Eq + Hash + Send + Sync + 'static,
+    V: fmt::Debug + Clone + Send + Sync + 'static,
+    // TODO: Remove these bounds from S.
+    S: BuildHasher + Clone + Send + Sync + 'static,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut d_map = f.debug_map();
+
+        for (k, v) in self.iter() {
+            d_map.entry(&k, &v);
+        }
+
+        d_map.finish()
+    }
+}
+
 impl<K, V, S> Cache<K, V, S> {
     /// Returns a read-only cache policy of this cache.
     ///
@@ -2137,4 +2156,19 @@ mod tests {
             Ok(5)
         );
     }
+
+    #[tokio::test]
+    async fn test_debug_format() {
+        let cache = Cache::new(10);
+        cache.insert('a', "alice").await;
+        cache.insert('b', "bob").await;
+        cache.insert('c', "cindy").await;
+
+        let debug_str = format!("{:?}", cache);
+        assert!(debug_str.starts_with('{'));
+        assert!(debug_str.contains(r#"'a': "alice""#));
+        assert!(debug_str.contains(r#"'b': "bob""#));
+        assert!(debug_str.contains(r#"'c': "cindy""#));
+        assert!(debug_str.ends_with('}'));
+    }
 }

src/sync/cache.rs

@@ -12,6 +12,7 @@ use std::{
     any::TypeId,
     borrow::Borrow,
     collections::hash_map::RandomState,
+    fmt,
     hash::{BuildHasher, Hash},
     sync::Arc,
     time::Duration,
@@ -263,6 +264,24 @@ impl<K, V, S> Clone for Cache<K, V, S> {
     }
 }
 
+impl<K, V, S> fmt::Debug for Cache<K, V, S>
+where
+    K: fmt::Debug + Eq + Hash + Send + Sync + 'static,
+    V: fmt::Debug + Clone + Send + Sync + 'static,
+    // TODO: Remove these bounds from S.
+    S: BuildHasher + Clone + Send + Sync + 'static,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut d_map = f.debug_map();
+
+        for (k, v) in self.iter() {
+            d_map.entry(&k, &v);
+        }
+
+        d_map.finish()
+    }
+}
+
 impl<K, V, S> Cache<K, V, S> {
     /// Returns a read-only cache policy of this cache.
     ///
@@ -1899,4 +1918,19 @@ mod tests {
             Ok(5)
         );
     }
+
+    #[test]
+    fn test_debug_format() {
+        let cache = Cache::new(10);
+        cache.insert('a', "alice");
+        cache.insert('b', "bob");
+        cache.insert('c', "cindy");
+
+        let debug_str = format!("{:?}", cache);
+        assert!(debug_str.starts_with('{'));
+        assert!(debug_str.contains(r#"'a': "alice""#));
+        assert!(debug_str.contains(r#"'b': "bob""#));
+        assert!(debug_str.contains(r#"'c': "cindy""#));
+        assert!(debug_str.ends_with('}'));
+    }
 }

src/sync/segment.rs

@@ -8,6 +8,7 @@ use crate::{Policy, PredicateError};
 use std::{
     borrow::Borrow,
     collections::hash_map::RandomState,
+    fmt,
     hash::{BuildHasher, Hash, Hasher},
     sync::Arc,
     time::Duration,
@@ -57,6 +58,24 @@ impl<K, V, S> Clone for SegmentedCache<K, V, S> {
     }
 }
 
+impl<K, V, S> fmt::Debug for SegmentedCache<K, V, S>
+where
+    K: fmt::Debug + Eq + Hash + Send + Sync + 'static,
+    V: fmt::Debug + Clone + Send + Sync + 'static,
+    // TODO: Remove these bounds from S.
+    S: BuildHasher + Clone + Send + Sync + 'static,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut d_map = f.debug_map();
+
+        for (k, v) in self.iter() {
+            d_map.entry(&k, &v);
+        }
+
+        d_map.finish()
+    }
+}
+
 impl<K, V> SegmentedCache<K, V, RandomState>
 where
     K: Hash + Eq + Send + Sync + 'static,
@@ -1407,4 +1426,19 @@ mod tests {
             t.join().expect("Failed to join");
         }
     }
+
+    #[test]
+    fn test_debug_format() {
+        let cache = SegmentedCache::new(10, 4);
+        cache.insert('a', "alice");
+        cache.insert('b', "bob");
+        cache.insert('c', "cindy");
+
+        let debug_str = format!("{:?}", cache);
+        assert!(debug_str.starts_with('{'));
+        assert!(debug_str.contains(r#"'a': "alice""#));
+        assert!(debug_str.contains(r#"'b': "bob""#));
+        assert!(debug_str.contains(r#"'c': "cindy""#));
+        assert!(debug_str.ends_with('}'));
+    }
 }

src/unsync/cache.rs

@@ -16,6 +16,7 @@ use smallvec::SmallVec;
 use std::{
     borrow::Borrow,
     collections::{hash_map::RandomState, HashMap},
+    fmt,
     hash::{BuildHasher, Hash, Hasher},
     ptr::NonNull,
     rc::Rc,
@@ -178,6 +179,24 @@ pub struct Cache<K, V, S = RandomState> {
     expiration_clock: Option<Clock>,
 }
 
+impl<K, V, S> fmt::Debug for Cache<K, V, S>
+where
+    K: fmt::Debug + Eq + Hash,
+    V: fmt::Debug,
+    // TODO: Remove these bounds from S.
+    S: BuildHasher + Clone,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut d_map = f.debug_map();
+
+        for (k, v) in self.iter() {
+            d_map.entry(&k, &v);
+        }
+
+        d_map.finish()
+    }
+}
+
 impl<K, V> Cache<K, V, RandomState>
 where
     K: Hash + Eq,
@@ -1395,4 +1414,19 @@ mod tests {
             }
         };
     }
+
+    #[test]
+    fn test_debug_format() {
+        let mut cache = Cache::new(10);
+        cache.insert('a', "alice");
+        cache.insert('b', "bob");
+        cache.insert('c', "cindy");
+
+        let debug_str = format!("{:?}", cache);
+        assert!(debug_str.starts_with('{'));
+        assert!(debug_str.contains(r#"'a': "alice""#));
+        assert!(debug_str.contains(r#"'b': "bob""#));
+        assert!(debug_str.contains(r#"'c': "cindy""#));
+        assert!(debug_str.ends_with('}'));
+    }
 }