Merge branch 'main' into darkwater/main

Author: jonathanpallant

CHANGELOG.md

@@ -723,6 +723,8 @@ Initial release
 
 ### [defmt-rtt-next]
 
+* [#1006] Fix `available_buffer_size` ignoring available buffer space when `read < write`
+
 ### [defmt-rtt-v1.1.0] (2025-10-09)
 
 * [#968] Add `in_blocking_mode` public method
@@ -961,6 +963,7 @@ Initial release
 ---
 
 [#1007]: https://github.com/knurling-rs/defmt/pull/1007
+[#1006]: https://github.com/knurling-rs/defmt/pull/1006
 [#990]: https://github.com/knurling-rs/defmt/pull/990
 [#986]: https://github.com/knurling-rs/defmt/pull/986
 [#974]: https://github.com/knurling-rs/defmt/pull/974

defmt/tests/ui/log-missing-format-impl.stderr

@@ -2,8 +2,13 @@ error[E0277]: the trait bound `Foo: Format` is not satisfied
  --> tests/ui/log-missing-format-impl.rs:4:5
   |
 4 |     defmt::info!("{}", Foo)
-  |     ^^^^^^^^^^^^^^^^^^^^^^^ the trait `Format` is not implemented for `Foo`
+  |     ^^^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
   |
+help: the trait `Format` is not implemented for `Foo`
+ --> tests/ui/log-missing-format-impl.rs:1:1
+  |
+1 | struct Foo;
+  | ^^^^^^^^^^
   = help: the following other types implement trait `Format`:
             &T
             &mut T

firmware/defmt-rtt/src/channel.rs

@@ -111,9 +111,66 @@ impl Channel {
 fn available_buffer_size(read_cursor: usize, write_cursor: usize) -> usize {
     if read_cursor > write_cursor {
         read_cursor - write_cursor - 1
-    } else if read_cursor == 0 {
-        BUF_SIZE - write_cursor - 1
     } else {
-        BUF_SIZE - write_cursor
+        BUF_SIZE - write_cursor - 1 + read_cursor
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::available_buffer_size;
+    use crate::consts::BUF_SIZE;
+
+    #[test]
+    fn test_rtt_available_buffer_size() {
+        // Helper to simulate RTT buffer state
+        let avail = |read: usize, write: usize| available_buffer_size(read, write);
+
+        // --- Case 1: Buffer is EMPTY (write == read) ---
+        // Should have maximum available space: BUF_SIZE - 1
+        assert_eq!(avail(0, 0), BUF_SIZE - 1);
+        assert_eq!(avail(10, 10), BUF_SIZE - 1);
+        assert_eq!(avail(BUF_SIZE - 1, BUF_SIZE - 1), BUF_SIZE - 1);
+
+        // --- Case 2: Buffer is FULL ---
+        // Full condition: (write + 1) % BUF_SIZE == read
+        // i.e., write == (read - 1 + BUF_SIZE) % BUF_SIZE
+        assert_eq!(avail(0, BUF_SIZE - 1), 0); // write=BUF_SIZE-1, read=0 → full
+        assert_eq!(avail(5, 4), 0); // write=4, read=5 → full
+        assert_eq!(avail(1, 0), 0); // write=0, read=1 → full
+
+        // --- Case 3: Read ahead of Write (no wrap-around) ---
+        // e.g., read=10, write=5 → free space = [5..9] → size = 10 - 5 - 1 = 4
+        assert_eq!(avail(10, 5), 10 - 5 - 1);
+        assert_eq!(avail(BUF_SIZE - 1, 0), (BUF_SIZE - 1) - 0 - 1); // = BUF_SIZE - 2
+
+        // --- Case 4: Write has wrapped around, Read behind (wrap-around case) ---
+        // e.g., read=5, write=10 → free space = [10..BUF_SIZE-1] + [0..4]
+        // size = (BUF_SIZE - 10 - 1) + (5) = BUF_SIZE - 10 - 1 + 5
+        assert_eq!(avail(5, 10), BUF_SIZE - 10 - 1 + 5);
+        assert_eq!(avail(0, 1), BUF_SIZE - 1 - 1 + 0); // = BUF_SIZE - 2
+        assert_eq!(avail(1, BUF_SIZE - 1), BUF_SIZE - (BUF_SIZE - 1) - 1 + 1); // = 1
+
+        // --- Edge: Single byte free ---
+        // After filling BUF_SIZE - 2 bytes from empty, 1 byte remains
+        assert_eq!(avail(1, BUF_SIZE - 1), 1); // one byte free
+        assert_eq!(avail(2, BUF_SIZE - 1), 2); // one byte free: only position BUF_SIZE-1 is free? No.
+                                               // Actually: write=BUF_SIZE-1, read=2 → free = [BUF_SIZE-1] + [0,1] → but [0,1] is 2 bytes?
+                                               // Let's recompute: total free = (BUF_SIZE - (BUF_SIZE-1) - 1) + 2 = (0) + 2 = 2 → wait.
+
+        // Better: use invariant
+        // Total data in buffer = (write - read + BUF_SIZE) % BUF_SIZE
+        // Free = BUF_SIZE - 1 - data
+        let data_in_buffer = |read: usize, write: usize| (write + BUF_SIZE - read) % BUF_SIZE;
+        let free_should_be = |read: usize, write: usize| BUF_SIZE - 1 - data_in_buffer(read, write);
+
+        // Validate our function against this invariant
+        for read in 0..BUF_SIZE.min(64) {
+            for write in 0..BUF_SIZE.min(64) {
+                let expected = free_should_be(read, write);
+                let actual = avail(read, write);
+                assert_eq!(actual, expected, "Mismatch at read={read}, write={write}");
+            }
+        }
     }
 }