Add tests for macos libraries (#1347)

Author: CraftSpider

crates/mac_core/src/array.rs

@@ -71,3 +71,34 @@ impl<T: CoreType> CFArray<T> {
         unsafe { T::new_borrowed(ptr.cast()) }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::CFString;
+
+    #[test]
+    fn test_array_index() {
+        let foo = CFString::new("foo");
+        let bar = CFString::new("bar");
+
+        let arr = CFArray::new(&[foo.clone(), bar.clone()]);
+
+        assert_eq!(arr.get(0).as_type_ref(), foo.as_type_ref());
+        assert_eq!(arr.get(1).as_type_ref(), bar.as_type_ref());
+        assert_eq!(arr.get(0).as_str(), "foo");
+        assert_eq!(arr.get(1).as_str(), "bar");
+    }
+
+    #[test]
+    fn test_array_len() {
+        let empty = CFArray::<CFString>::empty();
+        let two = CFArray::new(&[CFString::new("foo"), CFString::new("bar")]);
+
+        assert!(empty.is_empty());
+        assert_eq!(empty.len(), 0);
+
+        assert!(!two.is_empty());
+        assert_eq!(two.len(), 2);
+    }
+}

crates/mac_core/src/dict.rs

@@ -75,6 +75,7 @@ cfty! {
 }
 
 impl<K: CoreType, V: CoreType> CFDictionary<K, V> {
+    // TODO: Bind the keys/values of P to K and V
     /// Create a new [`CFDictionary`] that contains the provided key/value pairs.
     pub fn new<P: Pairs>(pairs: P) -> CFDictionary<K, V> {
         let (keys, values) = pairs.into_pairs();
@@ -96,3 +97,31 @@ impl<K: CoreType, V: CoreType> CFDictionary<K, V> {
         unsafe { CFDictionary::new_owned(ptr) }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::CFString;
+
+    #[test]
+    fn test_new_arr() {
+        let one = CFString::new("1");
+        let two = CFString::new("2");
+        let three = CFString::new("3");
+        let four = CFString::new("4");
+
+        let _ = CFDictionary::<CFString, CFString>::new::<[(CFString, CFString); 0]>([]);
+        let _ = CFDictionary::<CFString, CFString>::new([(one, two), (three, four)]);
+    }
+
+    #[test]
+    fn test_new_vec() {
+        let one = CFString::new("1");
+        let two = CFString::new("2");
+        let three = CFString::new("3");
+        let four = CFString::new("4");
+
+        let _ = CFDictionary::<CFString, CFString>::new::<Vec<(CFString, CFString)>>(vec![]);
+        let _ = CFDictionary::<CFString, CFString>::new(vec![(one, two), (three, four)]);
+    }
+}

crates/mac_core/src/lib.rs

@@ -167,4 +167,24 @@ mod tests {
         assert_eq!(CFTypeId::of_val(&ty), CFTypeId::of::<CFArray<CFType>>());
         drop(ty);
     }
+
+    #[test]
+    fn test_downcast() {
+        let arr = CFArray::<CFType>::empty();
+        let ty = arr.into_ty();
+
+        assert!(unsafe { ty.downcast::<CFArray<CFType>>() }.is_ok());
+
+        let arr = CFArray::<CFType>::empty();
+        let ty = arr.into_ty();
+        assert!(unsafe { ty.downcast::<CFString>() }.is_err());
+
+        let str = CFString::new("");
+        let ty = str.into_ty();
+        assert!(unsafe { ty.downcast::<CFString>() }.is_ok());
+
+        let str = CFString::new("");
+        let ty = str.into_ty();
+        assert!(unsafe { ty.downcast::<CFArray<CFString>>() }.is_err());
+    }
 }

crates/mac_core/src/set.rs

@@ -26,3 +26,16 @@ impl<T: CoreType> CFSet<T> {
         unsafe { CFSet::new_owned(ptr) }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::CFString;
+
+    #[test]
+    fn test_new() {
+        // Ensure empty and with-value set construction don't segfault
+        let _ = CFSet::<CFString>::new(&[]);
+        let _ = CFSet::new(&[CFString::new("foo")]);
+    }
+}

crates/mac_core/src/string.rs

@@ -29,7 +29,7 @@ impl StrLike for CStr {
         if self.to_str().is_ok() {
             sys::kCFStringEncodingUTF8
         } else {
-            sys::kCFStringEncodingNonLossyASCII
+            sys::kCFStringEncodingASCII
         }
     }
 
@@ -139,7 +139,7 @@ impl CFString {
     }
 
     /// Get this value as a null-terminated C-string
-    pub fn get_cstring(&self) -> CString {
+    pub fn get_cstring(&self) -> Option<CString> {
         let len = self.len() * 4 + 1;
         let mut buf = vec![0; len];
         // SAFETY: Self is guaranteed valid. Buffer is definitely of sufficient length to hold the
@@ -154,24 +154,61 @@ impl CFString {
         };
         if res {
             let buf = buf.into_iter().take_while(|&c| c != 0).collect::<Vec<_>>();
-            CString::new(buf).unwrap()
+            if buf.len() != self.len() {
+                None
+            } else {
+                Some(CString::new(buf).unwrap())
+            }
         } else {
-            panic!("Invalid C String")
+            None
         }
     }
 
     /// Attempt to get a reference to this value as a `CStr`, if the value is natively UTF-8,
     /// otherwise allocate a CString in that encoding.
-    pub fn as_cstr(&self) -> Cow<'_, CStr> {
+    pub fn as_cstr(&self) -> Option<Cow<'_, CStr>> {
         // SAFETY: Self is guaranteed valid
         let cstr =
             unsafe { sys::CFStringGetCStringPtr(self.as_type_ref(), sys::kCFStringEncodingUTF8) };
         if cstr.is_null() {
-            Cow::Owned(self.get_cstring())
+            self.get_cstring().map(Cow::Owned)
         } else {
             // SAFETY: If non-null, the return value of CFStringGetCStringPtr is guaranteed to be a
             //         valid C-string
-            Cow::Borrowed(unsafe { CStr::from_ptr(cstr) })
+            Some(Cow::Borrowed(unsafe { CStr::from_ptr(cstr) }))
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_as_str() {
+        let str = CFString::new("foo");
+        assert_eq!(str.as_str(), Cow::Borrowed("foo"));
+
+        let cstr = CFString::new(c"foo");
+        assert_eq!(cstr.as_str(), Cow::Borrowed("foo"));
+
+        // Invalid UTF-8 CStrings are treated as extended-ASCII.
+        let non_str = CFString::new(c"\xC3\x28bar");
+        assert_eq!(non_str.as_str(), Cow::<str>::Owned("Ã(bar".to_string()));
+    }
+
+    #[test]
+    fn test_as_cstr() {
+        let str = CFString::new("foo");
+        assert_eq!(str.as_cstr(), Some(Cow::<CStr>::Owned(c"foo".to_owned())));
+
+        let cstr = CFString::new(c"foo");
+        assert_eq!(cstr.as_cstr(), Some(Cow::Borrowed(c"foo")));
+    }
+
+    #[test]
+    fn test_as_non_cstr() {
+        let non_cstr = CFString::new("fo\0o");
+        assert!(non_cstr.as_cstr().is_none());
+    }
+}

crates/mac_core/src/sys.rs

@@ -78,6 +78,7 @@ pub const kCFStringEncodingASCII: CFStringEncoding = 0x0600;
 pub const kCFStringEncodingNonLossyASCII: CFStringEncoding = 0x0BFF;
 pub const kCFStringEncodingUnicode: CFStringEncoding = 0x0100;
 pub const kCFStringEncodingUTF8: CFStringEncoding = 0x08000100;
+pub const kCFStringEncodingInvalidId: CFStringEncoding = 0xFFFFFFFF;
 
 #[link(name = "CoreFoundation", kind = "framework")]
 extern "C" {

crates/xetex_layout/Cargo.toml

@@ -44,7 +44,7 @@ tectonic_mac_core = { path = "../mac_core", version = "0.0.0-dev.0" }
 external-harfbuzz = ["tectonic_bridge_harfbuzz/external-harfbuzz"]
 
 [package.metadata.internal_dep_versions]
-tectonic_mac_core = "6932d5f15fec0fb5c219b887bdd11b72641af07a"
+tectonic_mac_core = "thiscommit:2026-04-27:052BNSA"
 tectonic_bridge_core = "thiscommit:2021-01-16:wie2Ejoh"
 tectonic_bridge_fontconfig = "89268e8317eee0e23f9c0d572aa764d4504d85b5"
 tectonic_bridge_graphite2 = "2722731f9e32c6963fe8c8566a201b33672c5c5a"

crates/xetex_layout/src/font.rs

@@ -581,7 +581,9 @@ pub(crate) fn get_file_name_from_ct_font(ct_font: &CTFont, index: &mut u32) -> O
                             *index = i as u32;
                             break;
                         }
-                        (Some(name1), Some(name2)) if &*name1.as_cstr() == name2 => {
+                        (Some(name1), Some(name2))
+                            if name1.as_cstr().is_some_and(|name1| name1 == name2) =>
+                        {
                             *index = i as u32;
                             break;
                         }

crates/xetex_layout/src/manager/mac.rs

@@ -30,12 +30,12 @@ fn find_font_with_name(name: CFString, key: FontAttribute) -> Option<CTFontDescr
 
 fn append_name_to_list(font: &CTFont, name_list: &mut Vec<CString>, name_key: FontNameKey) {
     let name = font.name(name_key);
-    if let Some(name) = name {
-        FontManager::append_to_list(name_list, name.as_cstr());
+    if let Some(name) = name.as_ref().and_then(|n| n.as_cstr()) {
+        FontManager::append_to_list(name_list, name);
     }
     let name = font.localized_name(name_key);
-    if let Some(name) = name {
-        FontManager::append_to_list(name_list, name.as_cstr());
+    if let Some(name) = name.as_ref().and_then(|n| n.as_cstr()) {
+        FontManager::append_to_list(name_list, name);
     }
 }
 
@@ -152,7 +152,7 @@ impl FontManagerBackend for MacBackend {
         // SAFETY: CFString has no generic parameters
         let ps_name = unsafe { ps_name.downcast::<CFString>() }.unwrap();
 
-        names.ps_name = Some(ps_name.get_cstring());
+        names.ps_name = ps_name.get_cstring();
 
         let font = CTFont::new_descriptor(&font, 0.0);
         append_name_to_list(&font, &mut names.full_names, FontNameKey::Full);