Added tests for the unicode collation protocol

Author: d-sonuga

src/proto/mod.rs

@@ -74,4 +74,4 @@ pub mod pi;
 pub mod rng;
 pub mod security;
 pub mod shim;
-pub mod string;
+pub mod string;

src/proto/string/mod.rs

@@ -1,6 +1,6 @@
-//! String protocols
+//! String protocols.
 //!
 //! The protocols provide some string operations like
 //! lexical comparison.
 
-pub mod unicode_collation;
+pub mod unicode_collation;

src/proto/string/unicode_collation.rs

@@ -1,75 +1,43 @@
-//! The Unicode Collation Protocol
+//! The Unicode Collation Protocol.
 //!
-//! Used in the boot services environment to perform
-//! lexical comparison functions on Unicode strings for given languages
+//! This protocol is used in the boot services environment to perform
+//! lexical comparison functions on Unicode strings for given languages.
 
 use core::cmp::Ordering;
+use uefi::data_types::{CStr16, CStr8, Char16, Char8};
 use uefi_macros::{unsafe_guid, Protocol};
-use uefi::data_types::{Char16, CStr16, Char8, CStr8};
 
-/// The Unicode Collation Protocol
+/// The Unicode Collation Protocol.
 ///
-/// Used to perform case-insensitive comaprisons of strings
+/// Used to perform case-insensitive comaprisons of strings.
 #[repr(C)]
 #[unsafe_guid("a4c751fc-23ae-4c3e-92e9-4964cf63f349")]
 #[derive(Protocol)]
 pub struct UnicodeCollation {
-    stri_coll: extern "efiapi" fn(
-        this: &Self,
-        s1: *const Char16,
-        s2: *const Char16
-    ) -> isize,
-    metai_match: extern "efiapi" fn(
-        this: &Self,
-        string: *const Char16,
-        pattern: *const Char16
-    ) -> bool,
-    str_lwr: extern "efiapi" fn(
-        this: &Self,
-        s: *mut Char16
-    ),
-    str_upr: extern "efiapi" fn(
-        this: &Self,
-        s: *mut Char16
-    ),
-    fat_to_str: extern "efiapi" fn(
-        this: &Self,
-        fat_size: usize,
-        fat: *const Char8,
-        s: *mut Char16
-    ),
-    str_to_fat: extern "efiapi" fn(
-        this: &Self,
-        s: *const Char16,
-        fat_size: usize,
-        fat: *mut Char8
-    ) -> bool
+    stri_coll: extern "efiapi" fn(this: &Self, s1: *const Char16, s2: *const Char16) -> isize,
+    metai_match:
+        extern "efiapi" fn(this: &Self, string: *const Char16, pattern: *const Char16) -> bool,
+    str_lwr: extern "efiapi" fn(this: &Self, s: *mut Char16),
+    str_upr: extern "efiapi" fn(this: &Self, s: *mut Char16),
+    fat_to_str: extern "efiapi" fn(this: &Self, fat_size: usize, fat: *const Char8, s: *mut Char16),
+    str_to_fat:
+        extern "efiapi" fn(this: &Self, s: *const Char16, fat_size: usize, fat: *mut Char8) -> bool,
 }
 
 impl UnicodeCollation {
     /// Performs a case insensitive comparison of two
-    /// null-terminated strings 
+    /// null-terminated strings.
     pub fn stri_coll(&self, s1: &CStr16, s2: &CStr16) -> Ordering {
-        let order = (self.stri_coll)(
-            self,
-            s1.as_ptr(),
-            s2.as_ptr()
-        );
-        if order == 0 {
-            Ordering::Equal
-        } else if order < 0 {
-            Ordering::Less
-        } else {
-            Ordering::Greater
-        }
+        let order = (self.stri_coll)(self, s1.as_ptr(), s2.as_ptr());
+        order.cmp(&0)
     }
 
     /// Performs a case insensitive comparison between a null terminated
-    /// pattern string and a null terminated string
+    /// pattern string and a null terminated string.
     ///
     /// This function checks if character pattern described in `pattern`
     /// is found in `string`. If the pattern match succeeds, true is returned.
-    /// Otherwise, false is returned
+    /// Otherwise, false is returned.
     ///
     /// The following syntax can be used to build the string `pattern`:
     ///
@@ -85,77 +53,81 @@ impl UnicodeCollation {
     /// in ".FW", ".fw", ".Fw" or ".fW". The pattern "[a-z]" will match any
     /// letter in the alphabet. The pattern "z" will match the letter "z".
     /// The pattern "d?.*" will match the character "D" or "d" followed by
-    /// any single character followed by a "." followed by any string
+    /// any single character followed by a "." followed by any string.
     pub fn metai_match(&self, s: &CStr16, pattern: &CStr16) -> bool {
-        (self.metai_match)(
-            self,
-            s.as_ptr(),
-            pattern.as_ptr()
-        )
+        (self.metai_match)(self, s.as_ptr(), pattern.as_ptr())
     }
 
-    /// Converts the characters in `s` to lower case characters
-    pub fn str_lwr<'a>(&self, s: &CStr16, buf: &'a mut [u16]) -> Result<&'a CStr16, StrConversionError> {
+    /// Converts the characters in `s` to lower case characters.
+    pub fn str_lwr<'a>(
+        &self,
+        s: &CStr16,
+        buf: &'a mut [u16],
+    ) -> Result<&'a CStr16, StrConversionError> {
         let mut last_index = 0;
         for (i, c) in s.iter().enumerate() {
-            *buf.get_mut(i)
-                .ok_or(StrConversionError::BufferTooSmall)? = (*c).into();
+            *buf.get_mut(i).ok_or(StrConversionError::BufferTooSmall)? = (*c).into();
             last_index = i;
         }
         *buf.get_mut(last_index + 1)
             .ok_or(StrConversionError::BufferTooSmall)? = 0;
-        
-        (self.str_lwr)(
-            self,
-            buf.as_ptr() as *mut _
-        );
+
+        (self.str_lwr)(self, buf.as_ptr() as *mut _);
 
         Ok(unsafe { CStr16::from_u16_with_nul_unchecked(buf) })
     }
 
-    /// Coverts the characters in `s` to upper case characters
-    pub fn str_upr<'a>(&self, s: &CStr16, buf: &'a mut [u16]) -> Result<&'a CStr16, StrConversionError> {
+    /// Converts the characters in `s` to upper case characters.
+    pub fn str_upr<'a>(
+        &self,
+        s: &CStr16,
+        buf: &'a mut [u16],
+    ) -> Result<&'a CStr16, StrConversionError> {
         let mut last_index = 0;
         for (i, c) in s.iter().enumerate() {
-            *buf.get_mut(i)
-                .ok_or(StrConversionError::BufferTooSmall)? = (*c).into();
+            *buf.get_mut(i).ok_or(StrConversionError::BufferTooSmall)? = (*c).into();
             last_index = i;
         }
         *buf.get_mut(last_index + 1)
             .ok_or(StrConversionError::BufferTooSmall)? = 0;
-        
-        (self.str_upr)(
-            self,
-            buf.as_ptr() as *mut _
-        );
+
+        (self.str_upr)(self, buf.as_ptr() as *mut _);
 
         Ok(unsafe { CStr16::from_u16_with_nul_unchecked(buf) })
     }
 
-    /// Converts the 8.3 FAT file name `fat` to a null terminated string
-    pub fn fat_to_str<'a>(&self, fat: &CStr8, buf: &'a mut [u16]) -> Result<&'a CStr16, StrConversionError> {
+    /// Converts the 8.3 FAT file name `fat` to a null terminated string.
+    pub fn fat_to_str<'a>(
+        &self,
+        fat: &CStr8,
+        buf: &'a mut [u16],
+    ) -> Result<&'a CStr16, StrConversionError> {
         if buf.len() < fat.to_bytes_with_nul().len() {
             return Err(StrConversionError::BufferTooSmall);
         }
         (self.fat_to_str)(
             self,
             fat.to_bytes_with_nul().len(),
             fat.as_ptr(),
-            buf.as_ptr() as *mut _
+            buf.as_ptr() as *mut _,
         );
         Ok(unsafe { CStr16::from_u16_with_nul_unchecked(buf) })
     }
 
-    /// Converts the null terminated string `s` to legal characters in a FAT file name
-    pub fn str_to_fat<'a>(&self, s: &CStr16, buf: &'a mut [u8]) -> Result<&'a CStr8, StrConversionError> {
+    /// Converts the null terminated string `s` to legal characters in a FAT file name.
+    pub fn str_to_fat<'a>(
+        &self,
+        s: &CStr16,
+        buf: &'a mut [u8],
+    ) -> Result<&'a CStr8, StrConversionError> {
         if s.as_slice_with_nul().len() > buf.len() {
             return Err(StrConversionError::BufferTooSmall);
         }
         let failed = (self.str_to_fat)(
             self,
             s.as_ptr(),
             s.as_slice_with_nul().len(),
-            buf.as_ptr() as *mut _
+            buf.as_ptr() as *mut _,
         );
         if failed {
             Err(StrConversionError::ConversionFailed)
@@ -178,11 +150,11 @@ impl UnicodeCollation {
     }
 }
 
-/// Errors returned by [`UnicodeCollation::str_lwr`] and [`UnicodeCollation::str_upr`]
+/// Errors returned by [`UnicodeCollation::str_lwr`] and [`UnicodeCollation::str_upr`].
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum StrConversionError {
-    /// The conversion failed
+    /// The conversion failed.
     ConversionFailed,
-    /// The buffer given is too small to hold the string
-    BufferTooSmall
-}
+    /// The buffer given is too small to hold the string.
+    BufferTooSmall,
+}

uefi-test-runner/src/proto/mod.rs

@@ -19,6 +19,7 @@ pub fn test(image: Handle, st: &mut SystemTable<Boot>) {
     network::test(bt);
     pi::test(bt);
     rng::test(bt);
+    string::test(bt);
 
     #[cfg(any(
         target_arch = "i386",
@@ -71,3 +72,4 @@ mod rng;
     target_arch = "aarch64"
 ))]
 mod shim;
+mod string;

uefi-test-runner/src/proto/string/mod.rs

@@ -0,0 +1,9 @@
+use uefi::prelude::*;
+
+pub fn test(bt: &BootServices) {
+    info!("Testing String protocols");
+
+    unicode_collation::test(bt);
+}
+
+mod unicode_collation;

uefi-test-runner/src/proto/string/unicode_collation.rs

@@ -0,0 +1,99 @@
+use core::cmp::Ordering;
+use uefi::prelude::*;
+use uefi::proto::string::unicode_collation::{StrConversionError, UnicodeCollation};
+use uefi::{CStr16, CStr8};
+
+pub fn test(bt: &BootServices) {
+    info!("Testing the Unicode Collation protocol");
+
+    if let Ok(handles) = bt.find_handles::<UnicodeCollation>() {
+        for handle in handles {
+            let uc = bt
+                .open_protocol_exclusive::<UnicodeCollation>(handle)
+                .unwrap();
+
+            let mut buf1 = [0; 30];
+            let mut buf2 = [0; 30];
+
+            macro_rules! strings {
+                ($s1:expr, $s2:expr) => {{
+                    let s1 = CStr16::from_str_with_buf($s1, &mut buf1).unwrap();
+                    let s2 = CStr16::from_str_with_buf($s2, &mut buf2).unwrap();
+                    (s1, s2)
+                }};
+            }
+
+            let (s1, s2) = strings!("aab", "aaa");
+            // "aab" is lexically greater than "aaa"
+            assert_eq!(uc.stri_coll(s1, s2), Ordering::Greater);
+
+            let (s1, s2) = strings!("{}", "{}");
+            assert_eq!(uc.stri_coll(s1, s2), Ordering::Equal);
+
+            let (s1, s2) = strings!("\t", "-");
+            // Tab comes before dash in the unicode table
+            assert_eq!(uc.stri_coll(s1, s2), Ordering::Less);
+
+            let (s, pattern) = strings!("haaaaaaaaarderr", "h*a*r*derr");
+            assert!(uc.metai_match(s, pattern));
+
+            let (s, pattern) = strings!("haaaaaaaaarder0r", "h*a*r*derr");
+            assert!(!uc.metai_match(s, pattern));
+
+            let mut buf1 = [0; 13];
+            let s = CStr16::from_str_with_buf("HeLlO World!", &mut buf1).unwrap();
+
+            let mut buf2 = [0; 12];
+            assert_eq!(
+                uc.str_lwr(s, &mut buf2),
+                Err(StrConversionError::BufferTooSmall)
+            );
+
+            let mut buf2 = [0; 13];
+            let lower_s = uc.str_lwr(s, &mut buf2).unwrap();
+            assert_eq!(
+                lower_s,
+                CStr16::from_str_with_buf("hello world!", &mut [0; 13]).unwrap()
+            );
+
+            let mut buf = [0; 12];
+            assert_eq!(
+                uc.str_upr(s, &mut buf),
+                Err(StrConversionError::BufferTooSmall)
+            );
+
+            let mut buf = [0; 13];
+            let upper_s = uc.str_upr(s, &mut buf).unwrap();
+            assert_eq!(
+                upper_s,
+                CStr16::from_str_with_buf("HELLO WORLD!", &mut [0; 13]).unwrap()
+            );
+
+            let s = CStr8::from_bytes_with_nul(b"Hello World!\0").unwrap();
+            assert_eq!(
+                uc.fat_to_str(s, &mut [0; 12]),
+                Err(StrConversionError::BufferTooSmall)
+            );
+
+            assert_eq!(
+                uc.fat_to_str(s, &mut [0; 13]).unwrap(),
+                CStr16::from_str_with_buf("Hello World!", &mut [0; 13]).unwrap()
+            );
+
+            let mut buf = [0; 13];
+            let s = CStr16::from_str_with_buf("Hello World!", &mut buf).unwrap();
+            let mut buf = [0; 12];
+            assert_eq!(
+                uc.str_to_fat(s, &mut buf),
+                Err(StrConversionError::BufferTooSmall)
+            );
+            let mut buf = [0; 13];
+            assert_eq!(
+                uc.str_to_fat(s, &mut buf).unwrap(),
+                CStr8::from_bytes_with_nul(b"HELLOWORLD!\0").unwrap()
+            );
+        }
+    } else {
+        warn!("The Unicode Collation protocol is not supported");
+    }
+}