#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Sequence(u8);
impl Sequence {
pub const fn new() -> Self {
Sequence(0)
}
pub const fn from_raw(value: u8) -> Self {
Sequence(value)
}
pub const fn current(&self) -> u8 {
self.0
}
pub fn advance(&mut self) -> u8 {
let previous = self.0;
self.0 = self.0.wrapping_add(1);
previous
}
pub const fn previous(&self) -> u8 {
self.0.wrapping_sub(1)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn starts_at_zero() {
assert_eq!(Sequence::new().current(), 0);
}
#[test]
fn advance_returns_pre_increment_value() {
let mut seq = Sequence::new();
assert_eq!(seq.advance(), 0);
assert_eq!(seq.advance(), 1);
assert_eq!(seq.current(), 2);
}
#[test]
fn wraps_at_255_to_0() {
let mut seq = Sequence::new();
for _ in 0..255 {
seq.advance();
}
assert_eq!(seq.current(), 255);
assert_eq!(seq.advance(), 255);
assert_eq!(
seq.current(),
0,
"sequence must wrap 255 -> 0, not overflow"
);
}
#[test]
fn previous_wraps_0_to_255() {
let seq = Sequence::new();
assert_eq!(seq.previous(), 255);
}
#[test]
fn from_raw_preserves_value() {
assert_eq!(Sequence::from_raw(255).current(), 255);
assert_eq!(Sequence::from_raw(255).previous(), 254);
}
}