Screen API implementation

Author: inesmaria08

apis/interface/display/src/lib.rs

@@ -213,15 +213,15 @@ impl<S: Syscalls, C: Config> Display<S, C> {
         let called: Cell<Option<(u32,)>> = Cell::new(None);
         share::scope::<
             (
-                AllowRo<_, DRIVER_NUM, { allow_ro::SHARED }>,
+                AllowRo<_, DRIVER_NUM, { allow_ro::WRITE_BUFFER_ID }>,
                 Subscribe<_, DRIVER_NUM, { subscribe::WRITE }>,
             ),
             _,
             _,
         >(|handle| {
             let (allow_ro, subscribe) = handle.split();
 
-            S::allow_ro::<C, DRIVER_NUM, { allow_ro::SHARED }>(allow_ro, s)?;
+            S::allow_ro::<C, DRIVER_NUM, { allow_ro::WRITE_BUFFER_ID }>(allow_ro, s)?;
 
             S::subscribe::<_, _, C, DRIVER_NUM, { subscribe::WRITE }>(subscribe, &called)?;
 
@@ -236,34 +236,37 @@ impl<S: Syscalls, C: Config> Display<S, C> {
         })
     }
     pub fn fill(s: &mut [u8], color: u16) -> Result<(), ErrorCode> {
-        if s.len() - 2 > 0 {
+        if s.len() >= 2 {
             s[0] = ((color >> 8) & 0xFF) as u8;
             s[1] = (color & 0xFF) as u8;
-        }
-        let called: Cell<Option<(u32,)>> = Cell::new(None);
-        share::scope::<
-            (
-                AllowRo<_, DRIVER_NUM, { allow_ro::SHARED }>,
-                Subscribe<_, DRIVER_NUM, { subscribe::WRITE }>,
-            ),
-            _,
-            _,
-        >(|handle| {
-            let (allow_ro, subscribe) = handle.split();
 
-            S::allow_ro::<C, DRIVER_NUM, { allow_ro::SHARED }>(allow_ro, s)?;
+            let called: Cell<Option<(u32,)>> = Cell::new(None);
+            share::scope::<
+                (
+                    AllowRo<_, DRIVER_NUM, { allow_ro::WRITE_BUFFER_ID }>,
+                    Subscribe<_, DRIVER_NUM, { subscribe::WRITE }>,
+                ),
+                _,
+                _,
+            >(|handle| {
+                let (allow_ro, subscribe) = handle.split();
 
-            S::subscribe::<_, _, C, DRIVER_NUM, { subscribe::WRITE }>(subscribe, &called)?;
+                S::allow_ro::<C, DRIVER_NUM, { allow_ro::WRITE_BUFFER_ID }>(allow_ro, s)?;
 
-            let val = S::command(DRIVER_NUM, command::FILL, 0, 0).to_result();
+                S::subscribe::<_, _, C, DRIVER_NUM, { subscribe::WRITE }>(subscribe, &called)?;
 
-            loop {
-                S::yield_wait();
-                if let Some((_,)) = called.get() {
-                    return val;
+                let val = S::command(DRIVER_NUM, command::FILL, 0, 0).to_result();
+
+                loop {
+                    S::yield_wait();
+                    if let Some((_,)) = called.get() {
+                        return val;
+                    }
                 }
-            }
-        })
+            })
+        } else {
+            Err(ErrorCode::Fail)
+        }
     }
 }
 pub trait Config:
@@ -314,5 +317,5 @@ mod subscribe {
     pub const WRITE: u32 = 0;
 }
 mod allow_ro {
-    pub const SHARED: u32 = 0;
+    pub const WRITE_BUFFER_ID: u32 = 0;
 }

apis/interface/display/src/tests.rs

@@ -92,9 +92,20 @@ fn get_resolution_width_height() {
     let kernel = fake::Kernel::new();
     let driver = fake::Screen::new();
     kernel.add_driver(&driver);
-    assert_eq!(Screen::get_resolution_width_height(1), Ok((1920, 1080)));
+    assert_eq!(Screen::get_resolution_width_height(0), Ok((1920, 1080)));
+    assert_eq!(Screen::get_resolution_width_height(1), Ok((2560, 1440)));
+    assert_eq!(Screen::get_resolution_width_height(2), Ok((1280, 720)));
+}
+#[test]
+fn get_resolution_width_height_fail() {
+    let kernel = fake::Kernel::new();
+    let driver = fake::Screen::new();
+    kernel.add_driver(&driver);
+    assert_eq!(
+        Screen::get_resolution_width_height(3),
+        Err(ErrorCode::Invalid)
+    );
 }
-
 #[test]
 fn pixel_modes_count() {
     let kernel = fake::Kernel::new();
@@ -104,15 +115,24 @@ fn pixel_modes_count() {
 }
 
 #[test]
-fn pixel_format() {
+fn get_screen_pixel_format_success() {
     let kernel = fake::Kernel::new();
     let driver = fake::Screen::new();
     kernel.add_driver(&driver);
-    assert_eq!(Screen::pixel_format(1), Ok(1));
+    assert_eq!(Screen::pixel_format(0), Ok(332));
+    assert_eq!(Screen::pixel_format(1), Ok(565));
 }
 
 #[test]
-fn set_rotation() {
+fn get_screen_pixel_format_fail() {
+    let kernel = fake::Kernel::new();
+    let driver = fake::Screen::new();
+    kernel.add_driver(&driver);
+    assert_eq!(Screen::pixel_format(8), Err(ErrorCode::Invalid));
+}
+
+#[test]
+fn set_rotation_success() {
     let kernel = fake::Kernel::new();
     let driver = fake::Screen::new();
     kernel.add_driver(&driver);
@@ -125,7 +145,15 @@ fn set_rotation() {
 }
 
 #[test]
-fn get_rotation() {
+fn set_rotation_fail() {
+    let kernel = fake::Kernel::new();
+    let driver = fake::Screen::new();
+    kernel.add_driver(&driver);
+    assert_eq!(Screen::set_rotation(360), Err(ErrorCode::Invalid));
+}
+
+#[test]
+fn get_rotation_success() {
     let kernel = fake::Kernel::new();
     let driver = fake::Screen::new();
     kernel.add_driver(&driver);
@@ -143,6 +171,19 @@ fn get_rotation() {
     assert_eq!(Screen::get_rotation(), Ok(30));
 }
 
+#[test]
+fn get_rotation_fail() {
+    let kernel = fake::Kernel::new();
+    let driver = fake::Screen::new();
+    kernel.add_driver(&driver);
+    kernel.add_expected_syscall(ExpectedSyscall::Subscribe {
+        driver_num: 0x90001,
+        subscribe_num: 0,
+        skip_with_error: None,
+    });
+    assert_eq!(Screen::get_rotation(), Ok(0));
+}
+
 #[test]
 fn set_resolution() {
     let kernel = fake::Kernel::new();
@@ -157,7 +198,7 @@ fn set_resolution() {
 }
 
 #[test]
-fn get_resolution() {
+fn get_resolution_sucess() {
     let kernel = fake::Kernel::new();
     let driver = fake::Screen::new();
     kernel.add_driver(&driver);
@@ -170,6 +211,14 @@ fn get_resolution() {
     assert_eq!(Screen::get_resolution(), Ok((360, 720)));
 }
 
+#[test]
+fn get_resolution_fail() {
+    let kernel = fake::Kernel::new();
+    let driver = fake::Screen::new();
+    kernel.add_driver(&driver);
+    assert_eq!(Screen::get_resolution(), Ok((0, 0)));
+}
+
 #[test]
 fn set_pixel_format() {
     let kernel = fake::Kernel::new();
@@ -184,7 +233,7 @@ fn set_pixel_format() {
 }
 
 #[test]
-fn get_pixel_format() {
+fn get_pixel_format_success() {
     let kernel = fake::Kernel::new();
     let driver = fake::Screen::new();
     kernel.add_driver(&driver);
@@ -197,12 +246,20 @@ fn get_pixel_format() {
     assert_eq!(Screen::get_pixel_format(), Ok(2));
 }
 
+#[test]
+fn get_pixel_format_fail() {
+    let kernel = fake::Kernel::new();
+    let driver = fake::Screen::new();
+    kernel.add_driver(&driver);
+    assert_eq!(Screen::get_pixel_format(), Ok(0));
+}
+
 #[test]
 fn set_write_frame() {
     let kernel = fake::Kernel::new();
     let driver = fake::Screen::new();
     kernel.add_driver(&driver);
-    assert_eq!(Screen::set_write_frame(4660, 22136, 39612, 57072), Ok(()));
+    assert_eq!(Screen::set_write_frame(10, 20, 30, 30), Ok(()));
 }
 
 #[test]
@@ -213,15 +270,63 @@ fn write_buffer() {
     let _ = Screen::set_pixel_format(2);
     let buffer = [0u8; 4];
 
+    kernel.add_expected_syscall(ExpectedSyscall::AllowRo {
+        driver_num: 0x90001,
+        buffer_num: 0,
+        return_error: None,
+    });
+
     kernel.add_expected_syscall(ExpectedSyscall::Subscribe {
         driver_num: 0x90001,
         subscribe_num: 0,
         skip_with_error: None,
     });
+
+    assert_eq!(Screen::write(&buffer), Ok(()));
+}
+
+#[test]
+fn fill_success() {
+    let kernel = fake::Kernel::new();
+    let driver = fake::Screen::new();
+    kernel.add_driver(&driver);
+    let _ = Screen::set_pixel_format(2);
+    let mut buffer = [0u8; 2];
+    let color = 0xF800;
     kernel.add_expected_syscall(ExpectedSyscall::AllowRo {
         driver_num: 0x90001,
         buffer_num: 0,
         return_error: None,
     });
-    assert_eq!(Screen::write(&buffer), Ok(()));
+
+    kernel.add_expected_syscall(ExpectedSyscall::Subscribe {
+        driver_num: 0x90001,
+        subscribe_num: 0,
+        skip_with_error: None,
+    });
+
+    assert_eq!(Screen::fill(&mut buffer, color), Ok(()));
+}
+
+#[test]
+fn fill_fail() {
+    let kernel = fake::Kernel::new();
+    let driver = fake::Screen::new();
+    kernel.add_driver(&driver);
+    let _ = Screen::set_pixel_format(2);
+    let mut buffer = [0u8; 1];
+    let color = 0xF800;
+    kernel.add_expected_syscall(ExpectedSyscall::AllowRo {
+        driver_num: 0x90001,
+        buffer_num: 0,
+        return_error: None,
+    });
+
+    kernel.add_expected_syscall(ExpectedSyscall::Subscribe {
+        driver_num: 0x90001,
+        subscribe_num: 0,
+        skip_with_error: None,
+    });
+
+    assert_eq!(Screen::fill(&mut buffer, color), Err(ErrorCode::Fail));
 }