Enable queue use on a single page

Author: diondokter

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - Added `Key` implementation for the unit type `()` for easy storage of a single value
 - *Breaking:* Changed API for map `fetch_all_items` such that the `Key` is captured in `MapItemIter`.
+- Fixed some logic so queue can be used on a single page. (It's still recommended to use at least 2 pages for both the queue and the map)
 
 ## 4.0.3 18-06-25
 

src/lib.rs

@@ -434,7 +434,10 @@ where
         match self {
             Error::Storage { value, .. } => write!(f, "Storage error: {value}"),
             Error::FullStorage => write!(f, "Storage is full"),
+            #[cfg(not(feature = "_test"))]
             Error::Corrupted { .. } => write!(f, "Storage is corrupted"),
+            #[cfg(feature = "_test")]
+            Error::Corrupted { backtrace } => write!(f, "Storage is corrupted\n{backtrace}"),
             Error::BufferTooBig => write!(f, "A provided buffer was to big to be used"),
             Error::BufferTooSmall(needed) => write!(
                 f,

src/mock_flash.rs

@@ -1,4 +1,7 @@
-use core::ops::{Add, AddAssign, Range};
+use core::{
+    fmt::Display,
+    ops::{Add, AddAssign, Range},
+};
 use embedded_storage_async::nor_flash::{
     ErrorType, MultiwriteNorFlash, NorFlash, NorFlashError, NorFlashErrorKind, ReadNorFlash,
 };
@@ -374,6 +377,12 @@ pub enum MockFlashError {
     EarlyShutoff(u32, Operation),
 }
 
+impl Display for MockFlashError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{self:?}")
+    }
+}
+
 impl NorFlashError for MockFlashError {
     fn kind(&self) -> NorFlashErrorKind {
         match self {

src/queue.rs

@@ -140,34 +140,45 @@ async fn push_inner<S: NorFlash>(
     if next_address.is_none() {
         // No cap left on this page, move to the next page
         let next_page = next_page::<S>(flash_range.clone(), current_page);
-        match get_page_state(flash, flash_range.clone(), cache, next_page).await? {
-            PageState::Open => {
+        let next_page_state = get_page_state(flash, flash_range.clone(), cache, next_page).await?;
+        let single_page = next_page == current_page;
+
+        match (next_page_state, single_page) {
+            (PageState::Open, _) => {
                 close_page(flash, flash_range.clone(), cache, current_page).await?;
                 partial_close_page(flash, flash_range.clone(), cache, next_page).await?;
                 next_address = Some(
                     calculate_page_address::<S>(flash_range.clone(), next_page)
                         + S::WORD_SIZE as u32,
                 );
             }
-            state @ PageState::Closed => {
+            (PageState::Closed, _) | (PageState::PartialOpen, true) => {
                 let next_page_data_start_address =
                     calculate_page_address::<S>(flash_range.clone(), next_page)
                         + S::WORD_SIZE as u32;
 
                 if !allow_overwrite_old_data
-                    && !is_page_empty(flash, flash_range.clone(), cache, next_page, Some(state))
-                        .await?
+                    && !is_page_empty(
+                        flash,
+                        flash_range.clone(),
+                        cache,
+                        next_page,
+                        Some(next_page_state),
+                    )
+                    .await?
                 {
                     cache.unmark_dirty();
                     return Err(Error::FullStorage);
                 }
 
                 open_page(flash, flash_range.clone(), cache, next_page).await?;
-                close_page(flash, flash_range.clone(), cache, current_page).await?;
+                if !single_page {
+                    close_page(flash, flash_range.clone(), cache, current_page).await?;
+                }
                 partial_close_page(flash, flash_range.clone(), cache, next_page).await?;
                 next_address = Some(next_page_data_start_address);
             }
-            PageState::PartialOpen => {
+            (PageState::PartialOpen, false) => {
                 // This should never happen
                 return Err(Error::Corrupted {
                     #[cfg(feature = "_test")]
@@ -1525,4 +1536,29 @@ mod tests {
             Err(Error::ItemTooBig)
         );
     }
+
+    #[test]
+    async fn push_on_single_page() {
+        let mut flash =
+            mock_flash::MockFlashBase::<1, 4, 256>::new(WriteCountCheck::Twice, None, true);
+        const FLASH_RANGE: Range<u32> = 0x000..0x400;
+
+        for _ in 0..100 {
+            match push(
+                &mut flash,
+                FLASH_RANGE,
+                &mut cache::NoCache::new(),
+                &[0, 1, 2, 3, 4],
+                true,
+            )
+            .await
+            {
+                Ok(_) => {}
+                Err(e) => {
+                    println!("{}", flash.print_items().await);
+                    panic!("{e}");
+                }
+            }
+        }
+    }
 }