Fix and update test

Author: ia0

examples/nvmc-demo/memory.x

@@ -1,12 +1,12 @@
 MEMORY
 {
   /* NOTE 1 K = 1 KiB = 1024 bytes */
-  FLASH : ORIGIN = 0x00000000, LENGTH = 1024K - 16K
-  /* We use 6 pages of 4 KiB each */
-  CONFIG : ORIGIN = ORIGIN(FLASH) + LENGTH(FLASH), LENGTH = 6 * 4K
+  FLASH : ORIGIN = 0x00000000, LENGTH = 1024K - NUM_PAGES * 4K
+  CONFIG : ORIGIN = ORIGIN(FLASH) + LENGTH(FLASH), LENGTH = NUM_PAGES * 4K
   RAM : ORIGIN = 0x20000000, LENGTH = 256K
 }
 
+NUM_PAGES = 6;
 _config = ORIGIN(CONFIG);
 
 /* This is where the call stack will be allocated. */

examples/nvmc-demo/src/main.rs

@@ -14,12 +14,12 @@ use hal::pac::NVMC;
 use panic_probe as _;
 use rtt_target::{rprintln, rtt_init_print};
 
-const NUM_PAGES: usize = 6;
+const NUM_PAGES: u32 = 6;
 const PAGE_SIZE: u32 = 4 * 1024;
-const LAST_PAGE: u32 = 3 * PAGE_SIZE;
+const LAST_PAGE: u32 = (NUM_PAGES - 1) * PAGE_SIZE;
 extern "C" {
     #[link_name = "_config"]
-    static mut CONFIG: [u8; NUM_PAGES * PAGE_SIZE as usize];
+    static mut CONFIG: [u8; (NUM_PAGES * PAGE_SIZE) as usize];
 }
 
 // To run this example:

nrf52840-hal-tests/memory.x

@@ -1,11 +1,12 @@
 MEMORY
 {
-  /* NOTE 1 K = 1 KiBi = 1024 bytes */
-  FLASH : ORIGIN = 0x00000000, LENGTH = 1020K
-  CONFIG : ORIGIN = ORIGIN(FLASH) + LENGTH(FLASH), LENGTH = 4K /* 4K is the flash page size */
+  /* NOTE 1 K = 1 KiB = 1024 bytes */
+  FLASH : ORIGIN = 0x00000000, LENGTH = 1024K - NUM_PAGES * 4K
+  CONFIG : ORIGIN = ORIGIN(FLASH) + LENGTH(FLASH), LENGTH = NUM_PAGES * 4K
   RAM : ORIGIN = 0x20000000, LENGTH = 256K
 }
 
+NUM_PAGES = 6;
 _config = ORIGIN(CONFIG);
 
 /* This is where the call stack will be allocated. */

nrf52840-hal-tests/tests/nvmc.rs

@@ -8,10 +8,13 @@ use panic_probe as _;
 use embedded_storage::nor_flash::{NorFlash, ReadNorFlash};
 use nrf52840_hal::{nvmc::Nvmc, pac};
 
-const CONFIG_SIZE: usize = 1024;
+const NUM_PAGES: u32 = 6; // must match memory.x
+const PAGE_SIZE: u32 = 4 * 1024;
+const LAST_PAGE: u32 = (NUM_PAGES - 1) * PAGE_SIZE;
+const CONFIG_SIZE: u32 = NUM_PAGES * PAGE_SIZE;
 extern "C" {
     #[link_name = "_config"]
-    static mut CONFIG: [u32; CONFIG_SIZE];
+    static mut CONFIG: [u8; CONFIG_SIZE as usize];
 }
 
 struct State {
@@ -35,66 +38,65 @@ mod tests {
 
     #[test]
     fn check_capacity(state: &mut State) {
-        assert_eq!(state.nvmc.capacity(), CONFIG_SIZE * 4);
+        assert_eq!(state.nvmc.capacity(), CONFIG_SIZE as usize);
     }
 
     #[test]
-    fn read_unaligned(state: &mut State) {
-        let mut buf = [0u8; 1];
-        assert!(state.nvmc.read(1, &mut buf).is_err());
+    fn read_outofbounds(state: &mut State) {
+        assert!(state.nvmc.read(CONFIG_SIZE, &mut [0]).is_err());
+        assert!(state.nvmc.read(CONFIG_SIZE - 1, &mut [0, 0]).is_err());
     }
 
     #[test]
-    fn read_beyond_buffer(state: &mut State) {
-        let mut buf = [0u8; CONFIG_SIZE * 4 + 1];
-        assert!(state.nvmc.read(0, &mut buf).is_err());
+    fn erase_unaligned(state: &mut State) {
+        assert!(state.nvmc.erase(LAST_PAGE + 1, PAGE_SIZE).is_err());
+        assert!(state.nvmc.erase(LAST_PAGE, PAGE_SIZE + 1).is_err());
     }
 
     #[test]
-    fn erase_unaligned_from(state: &mut State) {
-        assert!(state.nvmc.erase(1, 4096).is_err());
-    }
-
-    #[test]
-    fn erase_unaligned_to(state: &mut State) {
-        assert!(state.nvmc.erase(0, 4097).is_err());
+    fn erase_outofbounds(state: &mut State) {
+        assert!(state
+            .nvmc
+            .erase(CONFIG_SIZE, CONFIG_SIZE + PAGE_SIZE)
+            .is_err());
+        assert!(state
+            .nvmc
+            .erase(LAST_PAGE, LAST_PAGE + 2 * PAGE_SIZE)
+            .is_err());
     }
 
     #[test]
     fn write_unaligned(state: &mut State) {
-        let buf = [0u8; 1];
-        assert!(state.nvmc.write(1, &buf).is_err());
+        let buf = [0u8; 4];
+        assert!(state.nvmc.write(LAST_PAGE + 1, &buf).is_err());
+        assert!(state.nvmc.write(LAST_PAGE, &buf[..1]).is_err());
     }
 
     #[test]
     fn read_write_and_then_read(state: &mut State) {
-        assert!(state.nvmc.erase(0, CONFIG_SIZE as u32 * 4).is_ok());
-        let mut read_buf = [0u8; 1];
-        assert!(state.nvmc.read(0, &mut read_buf).is_ok());
+        assert!(state.nvmc.erase(LAST_PAGE, CONFIG_SIZE).is_ok());
+        let mut read_buf = [0];
+        assert!(state.nvmc.read(LAST_PAGE, &mut read_buf).is_ok());
         assert_eq!(read_buf[0], 0xff);
-        let write_buf = [1u8; 4];
-        assert!(state.nvmc.write(0, &write_buf).is_ok());
-        assert!(state.nvmc.read(0, &mut read_buf).is_ok());
-        assert_eq!(read_buf[0], 0x1);
+        let write_buf = [1, 2, 3, 4];
+        assert!(state.nvmc.write(LAST_PAGE, &write_buf).is_ok());
+        assert!(state.nvmc.read(LAST_PAGE, &mut read_buf).is_ok());
+        assert_eq!(read_buf[0], 1);
     }
 
     #[test]
     fn read_what_is_written(state: &mut State) {
-        assert!(state.nvmc.erase(0, CONFIG_SIZE as u32 * 4).is_ok());
+        assert!(state.nvmc.erase(LAST_PAGE, CONFIG_SIZE).is_ok());
         let write_buf: [u8; 8] = [1, 2, 3, 4, 5, 6, 7, 8];
-        assert!(state.nvmc.write(0, &write_buf).is_ok());
+        assert!(state.nvmc.write(LAST_PAGE, &write_buf).is_ok());
         let mut read_buf = [0u8; 8];
-        assert!(state.nvmc.read(0, &mut read_buf).is_ok());
+        assert!(state.nvmc.read(LAST_PAGE, &mut read_buf).is_ok());
         assert_eq!(read_buf, write_buf);
-    }
-
-    #[test]
-    fn partially_read_what_is_written(state: &mut State) {
-        assert!(state.nvmc.erase(0, CONFIG_SIZE as u32 * 4).is_ok());
-        let write_buf: [u8; 4] = [1, 2, 3, 4];
-        assert!(state.nvmc.write(0, &write_buf).is_ok());
-        let mut read_buf = [0u8; 2];
-        assert!(state.nvmc.read(0, &mut read_buf).is_ok());
-        assert_eq!(read_buf, write_buf[0..2]);
+        let mut partial_read_buf = [0u8; 4];
+        assert!(state
+            .nvmc
+            .read(LAST_PAGE + 2, &mut partial_read_buf)
+            .is_ok());
+        assert_eq!(partial_read_buf, write_buf[2..][..4]);
     }
 }