refactor(test): added test comments to assert statements

Author: PyDataBlog

tests/test_database.rs

@@ -8,7 +8,11 @@ fn test_insert_and_lookup_single_string() {
     db.insert("hello".to_string());
     let string_id = 0;
 
-    assert_eq!(db.get_string(string_id), Some("hello"));
+    assert_eq!(
+        db.get_string(string_id),
+        Some("hello"),
+        "Database should return 'hello' for string_id 0"
+    );
 
     let features_spurs = db.get_features(string_id).unwrap();
 
@@ -23,17 +27,26 @@ fn test_insert_and_lookup_single_string() {
         .into_iter()
         .map(String::from)
         .collect();
-    assert_eq!(features_strings, expected_features);
+    assert_eq!(
+        features_strings, expected_features,
+        "Extracted features should match expected 2-grams with counts for 'hello'"
+    );
 
     let feature_size = features_spurs.len();
     for feature_spur in features_spurs {
         let ids = db.lookup_strings(feature_size, *feature_spur).unwrap();
-        assert!(ids.contains(&string_id));
+        assert!(
+            ids.contains(&string_id),
+            "Each feature should map back to string_id 0"
+        );
     }
 
     let non_existent_spur = interner.get("xx1");
     if let Some(spur) = non_existent_spur {
-        assert!(db.lookup_strings(feature_size, spur).is_none());
+        assert!(
+            db.lookup_strings(feature_size, spur).is_none(),
+            "Non-existent feature 'xx1' should not return any string IDs"
+        );
     }
 }
 
@@ -48,20 +61,34 @@ fn test_lookup_separates_by_size() {
     let features_1 = db.get_features(1).unwrap();
     let size_0 = features_0.len();
     let size_1 = features_1.len();
-    assert_ne!(size_0, size_1);
+    assert_ne!(
+        size_0, size_1,
+        "Feature count for 'hello' and 'hellos' should be different"
+    );
 
-    // Fix: Bind the Arc to extend its lifetime
     let interner_arc = db.interner();
     let interner = interner_arc.lock().unwrap();
     let common_feature_spur = interner.get("#h1").unwrap();
 
     let ids_for_size_0 = db.lookup_strings(size_0, common_feature_spur).unwrap();
-    assert!(ids_for_size_0.contains(&0));
-    assert!(!ids_for_size_0.contains(&1));
+    assert!(
+        ids_for_size_0.contains(&0),
+        "Common feature '#h1' should be found in size bucket for 'hello' (id=0)"
+    );
+    assert!(
+        !ids_for_size_0.contains(&1),
+        "Size bucket for 'hello' should not contain 'hellos' (id=1)"
+    );
 
     let ids_for_size_1 = db.lookup_strings(size_1, common_feature_spur).unwrap();
-    assert!(ids_for_size_1.contains(&1));
-    assert!(!ids_for_size_1.contains(&0));
+    assert!(
+        ids_for_size_1.contains(&1),
+        "Common feature '#h1' should be found in size bucket for 'hellos' (id=1)"
+    );
+    assert!(
+        !ids_for_size_1.contains(&0),
+        "Size bucket for 'hellos' should not contain 'hello' (id=0)"
+    );
 }
 
 #[test]
@@ -79,23 +106,51 @@ fn test_insert_multiple_strings_same_size() {
 
     let at1_spur = interner.get("at1").unwrap();
     let ids = db.lookup_strings(feature_size, at1_spur).unwrap();
-    assert!(ids.contains(&0));
-    assert!(ids.contains(&1));
-    assert!(!ids.contains(&2));
+    assert!(
+        ids.contains(&0),
+        "Feature 'at1' should be found in 'cat' (id=0)"
+    );
+    assert!(
+        ids.contains(&1),
+        "Feature 'at1' should be found in 'bat' (id=1)"
+    );
+    assert!(
+        !ids.contains(&2),
+        "Feature 'at1' should not be found in 'dog' (id=2)"
+    );
 
     let og1_spur = interner.get("og1").unwrap();
     let ids_dog = db.lookup_strings(feature_size, og1_spur).unwrap();
-    assert!(ids_dog.contains(&2));
-    assert_eq!(ids_dog.len(), 1);
+    assert!(
+        ids_dog.contains(&2),
+        "Feature 'og1' should be found in 'dog' (id=2)"
+    );
+    assert_eq!(
+        ids_dog.len(),
+        1,
+        "Feature 'og1' should only be found in one string ('dog')"
+    );
 }
 
 #[test]
 fn test_initial_db_state() {
     let feature_extractor = Arc::new(CharacterNgrams::new(2, "$"));
     let db = HashDb::new(feature_extractor);
-    assert_eq!(db.max_feature_len(), 0);
-    assert_eq!(db.get_string(0), None);
-    assert_eq!(db.get_features(0), None);
+    assert_eq!(
+        db.max_feature_len(),
+        0,
+        "Empty database should have max_feature_len of 0"
+    );
+    assert_eq!(
+        db.get_string(0),
+        None,
+        "Empty database should return None for any string_id"
+    );
+    assert_eq!(
+        db.get_features(0),
+        None,
+        "Empty database should return None for any feature lookup"
+    );
 }
 
 #[test]
@@ -107,9 +162,17 @@ fn test_string_collection_retrieval() {
         db.insert(s.to_string());
     }
     for (id, &expected_string) in corpus.iter().enumerate() {
-        assert_eq!(db.get_string(id), Some(expected_string));
+        assert_eq!(
+            db.get_string(id),
+            Some(expected_string),
+            "Database should return correct string for id {id}"
+        );
     }
-    assert_eq!(db.get_string(corpus.len()), None);
+    assert_eq!(
+        db.get_string(corpus.len()),
+        None,
+        "Database should return None for out-of-bounds string_id"
+    );
 }
 
 #[test]
@@ -119,9 +182,18 @@ fn test_hashdb_debug_output() {
     db.insert("test".to_string());
     db.insert("apple".to_string());
     let debug_output = format!("{db:?}");
-    assert!(debug_output.contains("num_strings: 2"));
-    assert!(debug_output.contains("num_feature_size_buckets: 2"));
-    assert!(debug_output.contains("total_unique_features_interned: 11"));
+    assert!(
+        debug_output.contains("num_strings: 2"),
+        "Debug output should show 2 strings inserted"
+    );
+    assert!(
+        debug_output.contains("num_feature_size_buckets: 2"),
+        "Debug output should show 2 feature size buckets (different lengths)"
+    );
+    assert!(
+        debug_output.contains("total_unique_features_interned: 11"),
+        "Debug output should show 11 total unique features interned"
+    );
 }
 
 #[test]
@@ -130,16 +202,34 @@ fn test_db_clear() {
     let mut db = HashDb::new(feature_extractor);
     db.insert("test".to_string());
 
-    // Ensure DB is not empty
-    assert_eq!(db.get_string(0), Some("test"));
-    assert_eq!(db.max_feature_len(), 5);
+    assert_eq!(
+        db.get_string(0),
+        Some("test"),
+        "Database should contain 'test' before clear"
+    );
+    assert_eq!(
+        db.max_feature_len(),
+        5,
+        "Database should have max_feature_len of 5 before clear"
+    );
 
     db.clear();
 
-    // Ensure DB is now empty
-    assert_eq!(db.get_string(0), None);
-    assert_eq!(db.max_feature_len(), 0);
-    assert_eq!(db.interner().lock().unwrap().len(), 0);
+    assert_eq!(
+        db.get_string(0),
+        None,
+        "Database should return None after clear"
+    );
+    assert_eq!(
+        db.max_feature_len(),
+        0,
+        "Database should have max_feature_len of 0 after clear"
+    );
+    assert_eq!(
+        db.interner().lock().unwrap().len(),
+        0,
+        "Interner should be empty after clear"
+    );
 }
 
 #[test]
@@ -149,5 +239,9 @@ fn test_total_strings() {
     db.insert("test1".to_string());
     db.insert("test2".to_string());
 
-    assert_eq!(db.total_strings(), 2);
+    assert_eq!(
+        db.total_strings(),
+        2,
+        "Database should report 2 total strings after inserting 2 strings"
+    );
 }