Initial code review

lib/src/assert/mod.rs

@@ -171,46 +171,29 @@ impl AssertionInfo {
 
     // Verify that the TrackingInfo for self in 
     // ASSERT_TRACKER has been updated according to self.condition
-    fn track_entry(&self, tracker: &mut HashMap<String, TrackingInfo>) {
-
+    fn track_entry(&self) {
         // Requirement: Catalog entries must always will emit()
         if !self.hit {
             self.emit();
             return
         }
 
-        let tracking_key = self.id.clone(); 
-
         // Establish TrackingInfo for this trackingKey when needed
-        let maybe_info = tracker.get(&tracking_key);
-        if maybe_info.is_none() {
-            tracker.insert(self.id.clone(), TrackingInfo::new());
-        }
-
-        // Record the condition in the associated TrackingInfo entry
-        let condition = self.condition;
-        let tracked_entry = tracker.entry(self.id.clone());
-        tracked_entry.and_modify(|e: &mut TrackingInfo| {
-            if condition {
-                e.pass_count += 1;
-            } else {
-                e.fail_count += 1;
-            }
-        });
-
-        // Really emit the assertion when first seeing a condition
-        if let Some(tracking_info) = tracker.get(&tracking_key) {
-            let pass_count = tracking_info.pass_count;
-            let fail_count = tracking_info.fail_count;
-            if condition {
-                if pass_count == 1 {
-                    self.emit()
-                }
-            } else if fail_count == 1 {
-                self.emit()
-            }
+        let mut tracker = ASSERT_TRACKER.lock().unwrap();
+        let info = tracker.entry(self.id.clone()).or_default();
+        // Record the condition in the associated TrackingInfo entry,
+        // and emit the assertion when first seeing a condition
+        let emitting = if self.condition {
+            info.pass_count += 1;
+            info.pass_count == 1
+        } else {
+            info.fail_count += 1;
+            info.fail_count == 1
         };
-
+        drop(tracker); // release the lock asap
+        if emitting {
+            self.emit();
+        }
     }
 
     fn emit(&self) {
@@ -260,7 +243,7 @@ pub fn assert_impl(
 
 
     let assertion = AssertionInfo::new(assert_type, display_type, condition, message, class, function, file, begin_line, begin_column, hit, must_hit, id, details);
-    let _ = &assertion.track_entry(ASSERT_TRACKER.lock().as_deref_mut().unwrap());
+    let _ = &assertion.track_entry();
 }
 
 #[cfg(test)]
@@ -617,7 +600,7 @@ mod tests {
         let mut tracking_data = TrackingInfo::new();
 
         let tracking_key: String = key.to_owned();
-        match ASSERT_TRACKER.lock().as_deref().unwrap().get(&tracking_key) {
+        match ASSERT_TRACKER.lock().unwrap().get(&tracking_key) {
             None => tracking_data,
             Some(ti) => {
                 tracking_data.pass_count = ti.pass_count;

lib/src/internal/voidstar_handler.rs

@@ -1,7 +1,6 @@
-use libc::c_char;
+use libc::{c_char, size_t};
 use libloading::{Library, Symbol};
 use serde_json::{Value};
-use std::ffi::{CString};
 use std::io::{Error};
 use std::sync::{Once, Mutex, Arc};
 
@@ -44,10 +43,10 @@ impl VoidstarHandler {
 
 impl LibHandler for VoidstarHandler {
     fn output(&mut self, value: &Value) -> Result<(), Error> {
+        let payload = value.to_string();
         unsafe {
-            let json_data_func: Symbol<unsafe extern fn(s: *const c_char)> = self.voidstar_lib.get(b"fuzz_json_data").unwrap();
-            let payload = CString::new(value.to_string())?;
-            json_data_func(payload.as_ptr());
+            let json_data_func: Symbol<unsafe extern fn(s: *const c_char, l: size_t)> = self.voidstar_lib.get(b"fuzz_json_data").unwrap();
+            json_data_func(payload.as_bytes().as_ptr() as *const c_char, payload.len());
         }
         Ok(())
     }