From b23e40f72242a9f4759d8a6d4a924c8c9d041c67 Mon Sep 17 00:00:00 2001
From: Rasmus Melchior Jacobsen <rmja@laesoe.org>
Date: Tue, 30 May 2023 13:41:10 +0200
Subject: Add TestFlash helper

---
 embassy-boot/boot/src/test_flash/asynch.rs   | 57 ++++++++++++++++++++++++
 embassy-boot/boot/src/test_flash/blocking.rs | 65 ++++++++++++++++++++++++++++
 embassy-boot/boot/src/test_flash/mod.rs      |  7 +++
 3 files changed, 129 insertions(+)
 create mode 100644 embassy-boot/boot/src/test_flash/asynch.rs
 create mode 100644 embassy-boot/boot/src/test_flash/blocking.rs
 create mode 100644 embassy-boot/boot/src/test_flash/mod.rs

(limited to 'embassy-boot/boot/src/test_flash')

diff --git a/embassy-boot/boot/src/test_flash/asynch.rs b/embassy-boot/boot/src/test_flash/asynch.rs
new file mode 100644
index 000000000..b5b3c2538
--- /dev/null
+++ b/embassy-boot/boot/src/test_flash/asynch.rs
@@ -0,0 +1,57 @@
+use embassy_embedded_hal::flash::partition::Partition;
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
+use embassy_sync::mutex::Mutex;
+use embedded_storage_async::nor_flash::NorFlash;
+
+pub struct AsyncTestFlash<ACTIVE, DFU, STATE>
+where
+    ACTIVE: NorFlash,
+    DFU: NorFlash,
+    STATE: NorFlash,
+{
+    active: Mutex<NoopRawMutex, ACTIVE>,
+    dfu: Mutex<NoopRawMutex, DFU>,
+    state: Mutex<NoopRawMutex, STATE>,
+}
+
+impl<ACTIVE, DFU, STATE> AsyncTestFlash<ACTIVE, DFU, STATE>
+where
+    ACTIVE: NorFlash,
+    DFU: NorFlash,
+    STATE: NorFlash,
+{
+    pub fn new(active: ACTIVE, dfu: DFU, state: STATE) -> Self {
+        Self {
+            active: Mutex::new(active),
+            dfu: Mutex::new(dfu),
+            state: Mutex::new(state),
+        }
+    }
+
+    pub fn active(&self) -> Partition<NoopRawMutex, ACTIVE> {
+        Self::create_partition(&self.active)
+    }
+
+    pub fn dfu(&self) -> Partition<NoopRawMutex, DFU> {
+        Self::create_partition(&self.dfu)
+    }
+
+    pub fn state(&self) -> Partition<NoopRawMutex, STATE> {
+        Self::create_partition(&self.state)
+    }
+
+    fn create_partition<T: NorFlash>(mutex: &Mutex<NoopRawMutex, T>) -> Partition<NoopRawMutex, T> {
+        Partition::new(mutex, 0, mutex.try_lock().unwrap().capacity() as u32)
+    }
+}
+
+impl<ACTIVE, DFU, STATE> AsyncTestFlash<ACTIVE, DFU, STATE>
+where
+    ACTIVE: NorFlash + embedded_storage::nor_flash::NorFlash,
+    DFU: NorFlash + embedded_storage::nor_flash::NorFlash,
+    STATE: NorFlash + embedded_storage::nor_flash::NorFlash,
+{
+    pub fn into_blocking(self) -> super::BlockingTestFlash<ACTIVE, DFU, STATE> {
+        super::BlockingTestFlash::new(self.active.into_inner(), self.dfu.into_inner(), self.state.into_inner())
+    }
+}
diff --git a/embassy-boot/boot/src/test_flash/blocking.rs b/embassy-boot/boot/src/test_flash/blocking.rs
new file mode 100644
index 000000000..77876a218
--- /dev/null
+++ b/embassy-boot/boot/src/test_flash/blocking.rs
@@ -0,0 +1,65 @@
+use core::cell::RefCell;
+
+use embassy_embedded_hal::flash::partition::BlockingPartition;
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
+use embassy_sync::blocking_mutex::Mutex;
+use embedded_storage::nor_flash::NorFlash;
+
+pub struct BlockingTestFlash<ACTIVE, DFU, STATE>
+where
+    ACTIVE: NorFlash,
+    DFU: NorFlash,
+    STATE: NorFlash,
+{
+    active: Mutex<NoopRawMutex, RefCell<ACTIVE>>,
+    dfu: Mutex<NoopRawMutex, RefCell<DFU>>,
+    state: Mutex<NoopRawMutex, RefCell<STATE>>,
+}
+
+impl<ACTIVE, DFU, STATE> BlockingTestFlash<ACTIVE, DFU, STATE>
+where
+    ACTIVE: NorFlash,
+    DFU: NorFlash,
+    STATE: NorFlash,
+{
+    pub fn new(active: ACTIVE, dfu: DFU, state: STATE) -> Self {
+        Self {
+            active: Mutex::new(RefCell::new(active)),
+            dfu: Mutex::new(RefCell::new(dfu)),
+            state: Mutex::new(RefCell::new(state)),
+        }
+    }
+
+    pub fn active(&self) -> BlockingPartition<NoopRawMutex, ACTIVE> {
+        Self::create_partition(&self.active)
+    }
+
+    pub fn dfu(&self) -> BlockingPartition<NoopRawMutex, DFU> {
+        Self::create_partition(&self.dfu)
+    }
+
+    pub fn state(&self) -> BlockingPartition<NoopRawMutex, STATE> {
+        Self::create_partition(&self.state)
+    }
+
+    pub fn create_partition<T: NorFlash>(
+        mutex: &Mutex<NoopRawMutex, RefCell<T>>,
+    ) -> BlockingPartition<NoopRawMutex, T> {
+        BlockingPartition::new(mutex, 0, mutex.lock(|f| f.borrow().capacity()) as u32)
+    }
+}
+
+impl<ACTIVE, DFU, STATE> BlockingTestFlash<ACTIVE, DFU, STATE>
+where
+    ACTIVE: NorFlash + embedded_storage_async::nor_flash::NorFlash,
+    DFU: NorFlash + embedded_storage_async::nor_flash::NorFlash,
+    STATE: NorFlash + embedded_storage_async::nor_flash::NorFlash,
+{
+    pub fn into_async(self) -> super::AsyncTestFlash<ACTIVE, DFU, STATE> {
+        super::AsyncTestFlash::new(
+            self.active.into_inner().into_inner(),
+            self.dfu.into_inner().into_inner(),
+            self.state.into_inner().into_inner(),
+        )
+    }
+}
diff --git a/embassy-boot/boot/src/test_flash/mod.rs b/embassy-boot/boot/src/test_flash/mod.rs
new file mode 100644
index 000000000..a0672322e
--- /dev/null
+++ b/embassy-boot/boot/src/test_flash/mod.rs
@@ -0,0 +1,7 @@
+#[cfg(feature = "nightly")]
+mod asynch;
+mod blocking;
+
+#[cfg(feature = "nightly")]
+pub(crate) use asynch::AsyncTestFlash;
+pub(crate) use blocking::BlockingTestFlash;
-- 
cgit 


From c6a984f506530bc08464800abc332be9c49ac198 Mon Sep 17 00:00:00 2001
From: Rasmus Melchior Jacobsen <rmja@laesoe.org>
Date: Tue, 30 May 2023 13:55:49 +0200
Subject: Align tests

---
 embassy-boot/boot/src/test_flash/asynch.rs   | 17 ++++++++++++-----
 embassy-boot/boot/src/test_flash/blocking.rs | 22 +++++++++++++---------
 2 files changed, 25 insertions(+), 14 deletions(-)

(limited to 'embassy-boot/boot/src/test_flash')

diff --git a/embassy-boot/boot/src/test_flash/asynch.rs b/embassy-boot/boot/src/test_flash/asynch.rs
index b5b3c2538..3ac9e71ab 100644
--- a/embassy-boot/boot/src/test_flash/asynch.rs
+++ b/embassy-boot/boot/src/test_flash/asynch.rs
@@ -3,6 +3,8 @@ use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use embassy_sync::mutex::Mutex;
 use embedded_storage_async::nor_flash::NorFlash;
 
+use crate::BootLoaderConfig;
+
 pub struct AsyncTestFlash<ACTIVE, DFU, STATE>
 where
     ACTIVE: NorFlash,
@@ -20,11 +22,11 @@ where
     DFU: NorFlash,
     STATE: NorFlash,
 {
-    pub fn new(active: ACTIVE, dfu: DFU, state: STATE) -> Self {
+    pub fn new(config: BootLoaderConfig<ACTIVE, DFU, STATE>) -> Self {
         Self {
-            active: Mutex::new(active),
-            dfu: Mutex::new(dfu),
-            state: Mutex::new(state),
+            active: Mutex::new(config.active),
+            dfu: Mutex::new(config.dfu),
+            state: Mutex::new(config.state),
         }
     }
 
@@ -52,6 +54,11 @@ where
     STATE: NorFlash + embedded_storage::nor_flash::NorFlash,
 {
     pub fn into_blocking(self) -> super::BlockingTestFlash<ACTIVE, DFU, STATE> {
-        super::BlockingTestFlash::new(self.active.into_inner(), self.dfu.into_inner(), self.state.into_inner())
+        let config = BootLoaderConfig {
+            active: self.active.into_inner(),
+            dfu: self.dfu.into_inner(),
+            state: self.state.into_inner(),
+        };
+        super::BlockingTestFlash::new(config)
     }
 }
diff --git a/embassy-boot/boot/src/test_flash/blocking.rs b/embassy-boot/boot/src/test_flash/blocking.rs
index 77876a218..ba33c9208 100644
--- a/embassy-boot/boot/src/test_flash/blocking.rs
+++ b/embassy-boot/boot/src/test_flash/blocking.rs
@@ -5,6 +5,8 @@ use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use embassy_sync::blocking_mutex::Mutex;
 use embedded_storage::nor_flash::NorFlash;
 
+use crate::BootLoaderConfig;
+
 pub struct BlockingTestFlash<ACTIVE, DFU, STATE>
 where
     ACTIVE: NorFlash,
@@ -22,11 +24,11 @@ where
     DFU: NorFlash,
     STATE: NorFlash,
 {
-    pub fn new(active: ACTIVE, dfu: DFU, state: STATE) -> Self {
+    pub fn new(config: BootLoaderConfig<ACTIVE, DFU, STATE>) -> Self {
         Self {
-            active: Mutex::new(RefCell::new(active)),
-            dfu: Mutex::new(RefCell::new(dfu)),
-            state: Mutex::new(RefCell::new(state)),
+            active: Mutex::new(RefCell::new(config.active)),
+            dfu: Mutex::new(RefCell::new(config.dfu)),
+            state: Mutex::new(RefCell::new(config.state)),
         }
     }
 
@@ -49,6 +51,7 @@ where
     }
 }
 
+#[cfg(feature = "nightly")]
 impl<ACTIVE, DFU, STATE> BlockingTestFlash<ACTIVE, DFU, STATE>
 where
     ACTIVE: NorFlash + embedded_storage_async::nor_flash::NorFlash,
@@ -56,10 +59,11 @@ where
     STATE: NorFlash + embedded_storage_async::nor_flash::NorFlash,
 {
     pub fn into_async(self) -> super::AsyncTestFlash<ACTIVE, DFU, STATE> {
-        super::AsyncTestFlash::new(
-            self.active.into_inner().into_inner(),
-            self.dfu.into_inner().into_inner(),
-            self.state.into_inner().into_inner(),
-        )
+        let config = BootLoaderConfig {
+            active: self.active.into_inner().into_inner(),
+            dfu: self.dfu.into_inner().into_inner(),
+            state: self.state.into_inner().into_inner(),
+        };
+        super::AsyncTestFlash::new(config)
     }
 }
-- 
cgit