Add more unit tests

Author: gleocadie

libdd-crashtracker/src/collector/crash_handler.rs

@@ -266,3 +266,98 @@ fn handle_posix_signal_impl(
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_register_panic_hook() {        
+        assert!(PREVIOUS_PANIC_HOOK.load(SeqCst).is_null());
+
+        let result = register_panic_hook();
+        assert!(result.is_ok());
+        
+        assert!(!PREVIOUS_PANIC_HOOK.load(SeqCst).is_null());
+    }
+
+    #[test]
+    fn test_panic_message_storage_and_retrieval() {
+        // Test that panic messages can be stored and retrieved via atomic pointer
+        let test_message = "test panic message".to_string();
+        let message_ptr = Box::into_raw(Box::new(test_message.clone()));
+        
+        // Store the message
+        let old_ptr = PANIC_MESSAGE.swap(message_ptr, SeqCst);
+        assert!(old_ptr.is_null()); // Should be null initially
+        
+        // Retrieve and verify
+        let retrieved_ptr = PANIC_MESSAGE.swap(ptr::null_mut(), SeqCst);
+        assert!(!retrieved_ptr.is_null());
+        
+        unsafe {
+            let retrieved_message = *Box::from_raw(retrieved_ptr);
+            assert_eq!(retrieved_message, test_message);
+        }
+    }
+
+    #[test]
+    fn test_panic_message_null_handling() {
+        // Test that null message pointers are handled correctly
+        PANIC_MESSAGE.store(ptr::null_mut(), SeqCst);
+        
+        let message_ptr = PANIC_MESSAGE.load(SeqCst);
+        assert!(message_ptr.is_null());
+        
+        // Swapping null with null should be safe
+        let old_ptr = PANIC_MESSAGE.swap(ptr::null_mut(), SeqCst);
+        assert!(old_ptr.is_null());
+    }
+
+    #[test]
+    fn test_panic_message_replacement() {
+        // Test that replacing an existing message cleans up the old one
+        let message1 = "first message".to_string();
+        let message2 = "second message".to_string();
+        
+        let ptr1 = Box::into_raw(Box::new(message1));
+        let ptr2 = Box::into_raw(Box::new(message2.clone()));
+        
+        PANIC_MESSAGE.store(ptr1, SeqCst);
+        let old_ptr = PANIC_MESSAGE.swap(ptr2, SeqCst);
+        
+        // Old pointer should be the first one
+        assert_eq!(old_ptr, ptr1);
+        
+        // Clean up both
+        unsafe {
+            drop(Box::from_raw(old_ptr));
+            let final_ptr = PANIC_MESSAGE.swap(ptr::null_mut(), SeqCst);
+            let final_message = *Box::from_raw(final_ptr);
+            assert_eq!(final_message, message2);
+        }
+    }
+
+    #[test]
+    fn test_metadata_update_atomic() {
+        // Test that metadata updates are atomic
+        let metadata = Metadata {
+            library_name: "test".to_string(),
+            library_version: "1.0.0".to_string(),
+            family: "test_family".to_string(),
+            tags: vec![],
+        };
+        
+        let result = update_metadata(metadata.clone());
+        assert!(result.is_ok());
+        
+        // Verify metadata was stored
+        let metadata_ptr = METADATA.load(SeqCst);
+        assert!(!metadata_ptr.is_null());
+        
+        unsafe {
+            let (stored_metadata, _) = &*metadata_ptr;
+            assert_eq!(stored_metadata.library_name, "test");
+        }
+    }
+}

libdd-crashtracker/src/collector/emitters.rs

@@ -203,10 +203,12 @@ fn emit_metadata(w: &mut impl Write, metadata_str: &str) -> Result<(), EmitterEr
 fn emit_message(w: &mut impl Write, message_ptr: *mut String) -> Result<(), EmitterError> {
     if !message_ptr.is_null() {
         let message = unsafe { &*message_ptr };
-        writeln!(w, "{DD_CRASHTRACK_BEGIN_MESSAGE}")?;
-        writeln!(w, "{message}")?;
-        writeln!(w, "{DD_CRASHTRACK_END_MESSAGE}")?;
-        w.flush()?;
+        if !message.trim().is_empty() {
+            writeln!(w, "{DD_CRASHTRACK_BEGIN_MESSAGE}")?;
+            writeln!(w, "{message}")?;
+            writeln!(w, "{DD_CRASHTRACK_END_MESSAGE}")?;
+            w.flush()?;
+        }
     }
     Ok(())
 }
@@ -498,4 +500,101 @@ mod tests {
         // Clean up the allocated String
         unsafe { drop(Box::from_raw(message_ptr)) };
     }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_emit_message_empty_string() {
+        let empty_message = String::new();
+        let message_ptr = Box::into_raw(Box::new(empty_message));
+        let mut buf = Vec::new();
+
+        emit_message(&mut buf, message_ptr).expect("to work");
+
+        // Empty messages should not emit anything
+        assert!(buf.is_empty());
+
+        unsafe { drop(Box::from_raw(message_ptr)) };
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_emit_message_whitespace_only() {
+        // Whitespace-only messages should not be emitted
+        let whitespace_message = "   \n\t  ".to_string();
+        let message_ptr = Box::into_raw(Box::new(whitespace_message));
+        let mut buf = Vec::new();
+
+        emit_message(&mut buf, message_ptr).expect("to work");
+
+        // Whitespace-only messages should not emit anything
+        assert!(buf.is_empty());
+
+        unsafe { drop(Box::from_raw(message_ptr)) };
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_emit_message_with_leading_trailing_whitespace() {
+        // Messages with content and whitespace should be emitted (with the whitespace)
+        let message_with_whitespace = "  error message  ".to_string();
+        let message_ptr = Box::into_raw(Box::new(message_with_whitespace.clone()));
+        let mut buf = Vec::new();
+
+        emit_message(&mut buf, message_ptr).expect("to work");
+        let out = str::from_utf8(&buf).expect("to be valid UTF8");
+
+        // Should emit markers and preserve whitespace in content
+        assert!(out.contains("BEGIN_MESSAGE"));
+        assert!(out.contains("END_MESSAGE"));
+        assert!(out.contains(&message_with_whitespace));
+
+        unsafe { drop(Box::from_raw(message_ptr)) };
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_emit_message_with_newlines() {
+        let message_with_newlines = "line1\nline2\nline3".to_string();
+        let message_ptr = Box::into_raw(Box::new(message_with_newlines));
+        let mut buf = Vec::new();
+
+        emit_message(&mut buf, message_ptr).expect("to work");
+        let out = str::from_utf8(&buf).expect("to be valid UTF8");
+
+        assert!(out.contains("line1"));
+        assert!(out.contains("line2"));
+        assert!(out.contains("line3"));
+
+        unsafe { drop(Box::from_raw(message_ptr)) };
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_emit_message_unicode() {
+        let unicode_message = "Hello 世界 🦀 Rust!".to_string();
+        let message_ptr = Box::into_raw(Box::new(unicode_message.clone()));
+        let mut buf = Vec::new();
+
+        emit_message(&mut buf, message_ptr).expect("to work");
+        let out = str::from_utf8(&buf).expect("to be valid UTF8");
+
+        assert!(out.contains(&unicode_message));
+
+        unsafe { drop(Box::from_raw(message_ptr)) };
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_emit_message_very_long() {
+        let long_message = "x".repeat(100000); // 100KB
+        let message_ptr = Box::into_raw(Box::new(long_message.clone()));
+        let mut buf = Vec::new();
+
+        emit_message(&mut buf, message_ptr).expect("to work");
+        let out = str::from_utf8(&buf).expect("to be valid UTF8");
+
+        assert!(out.contains(&long_message[..100])); // At least first 100 chars
+
+        unsafe { drop(Box::from_raw(message_ptr)) };
+    }
 }

libdd-crashtracker/src/crash_info/builder.rs

@@ -453,4 +453,102 @@ mod tests {
         assert_eq!(crash_ping.metadata(), &metadata);
         assert!(crash_ping.message().contains("crash processing started"));
     }
+
+    #[test]
+    fn test_with_message() {
+        let mut builder = CrashInfoBuilder::new();
+        let test_message = "Test error message".to_string();
+
+        let result = builder.with_message(test_message.clone());
+        assert!(result.is_ok());
+        assert!(builder.has_message());
+
+        // Build and verify message is present
+        let sig_info = SigInfo::test_instance(42);
+        builder.with_sig_info(sig_info).unwrap();
+        builder.with_metadata(Metadata::test_instance(1)).unwrap();
+
+        let crash_ping = builder.build_crash_ping().unwrap();
+        assert!(crash_ping.message().contains(&test_message));
+    }
+
+    #[test]
+    fn test_has_message_empty() {
+        let builder = CrashInfoBuilder::new();
+        assert!(!builder.has_message());
+    }
+
+    #[test]
+    fn test_has_message_after_setting() {
+        let mut builder = CrashInfoBuilder::new();
+        builder.with_message("test".to_string()).unwrap();
+        assert!(builder.has_message());
+    }
+
+    #[test]
+    fn test_message_overwrite() {
+        let mut builder = CrashInfoBuilder::new();
+
+        builder.with_message("first message".to_string()).unwrap();
+        assert!(builder.has_message());
+
+        // Overwrite with second message
+        builder.with_message("second message".to_string()).unwrap();
+        assert!(builder.has_message());
+
+        // Build and verify only second message is present
+        let sig_info = SigInfo::test_instance(42);
+        builder.with_sig_info(sig_info).unwrap();
+        builder.with_metadata(Metadata::test_instance(1)).unwrap();
+
+        let crash_ping = builder.build_crash_ping().unwrap();
+        assert!(crash_ping.message().contains("second message"));
+        assert!(!crash_ping.message().contains("first message"));
+        builder.with_kind(ErrorKind::Panic).unwrap();
+
+        let report = builder.build().unwrap();
+        assert_eq!(
+            report.error.message.as_deref(),
+            Some("second message")
+        );
+    }
+
+    #[test]
+    fn test_message_with_special_characters() {
+        let mut builder = CrashInfoBuilder::new();
+        let special_message = "Error: 'panic' with \"quotes\" and\nnewlines\t\ttabs";
+
+        builder.with_message(special_message.to_string()).unwrap();
+        builder.with_sig_info(SigInfo::test_instance(42)).unwrap();
+        builder.with_metadata(Metadata::test_instance(1)).unwrap();
+
+        let crash_ping = builder.build_crash_ping().unwrap();
+        assert!(crash_ping.message().contains(&special_message));
+        builder.with_kind(ErrorKind::UnixSignal).unwrap();
+
+        let report = builder.build().unwrap();
+        assert_eq!(
+            report.error.message.as_deref(),
+            Some(special_message)
+        );
+    }
+
+    #[test]
+    fn test_very_long_message() {
+        let mut builder = CrashInfoBuilder::new();
+        let long_message = "x".repeat(10000); // 10KB message
+
+        builder.with_message(long_message.clone()).unwrap();
+        assert!(builder.has_message());
+
+        builder.with_sig_info(SigInfo::test_instance(42)).unwrap();
+        builder.with_metadata(Metadata::test_instance(1)).unwrap();
+
+        let crash_ping = builder.build_crash_ping().unwrap();
+        assert!(crash_ping.message().len() >= 10000);
+
+        builder.with_kind(ErrorKind::UnixSignal).unwrap();
+        let report = builder.build().unwrap();
+        assert!(report.error.message.as_ref().unwrap().len() >= 10000);
+    }
 }