mod control_app;
mod event;
mod known;
mod request;
pub use control_app::ControlApp;
pub use event::Event;
pub use known::Known;
pub use request::{MAX_OUTBOUND_LEN, Request};
use request::Outbound;
use crate::error::{Error, Result};
use crate::ids::{Bank, DeviceId, ProgramNumber, Slot};
use crate::nrpn::{Change, Nrpn};
use crate::param::{DEFAULT_FIRMWARE, ParamId};
use crate::program::Program;
use crate::queue::Queue;
use crate::sysex::inquiry::{self, Version};
use crate::sysex::{Frame, Identity, Message};
use crate::wire::{Channel, ChannelMessage, Decoder, Event as WireEvent, MAX_SYSEX_LEN};
pub const DEFAULT_TX_DEPTH: usize = 256;
pub const DEFAULT_EVENT_DEPTH: usize = 8;
pub const DEFAULT_TIMEOUT_MS: u64 = 2_000;
pub const MAX_PENDING: usize = 8;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Pending {
request: Request,
sent_at: u64,
}
#[derive(Debug)]
pub struct Device<
const RX: usize = MAX_SYSEX_LEN,
const TX: usize = DEFAULT_TX_DEPTH,
const EV: usize = DEFAULT_EVENT_DEPTH,
> {
id: DeviceId,
channel: Channel,
now: u64,
timeout: u64,
decoder: Decoder<RX>,
tx: Queue<Outbound, TX>,
events: Queue<Event, EV>,
lost: u16,
pending: [Option<Pending>; MAX_PENDING],
program: Known<Program>,
identity: Known<Identity>,
nrpn: Nrpn,
}
impl<const RX: usize, const TX: usize, const EV: usize> Device<RX, TX, EV> {
#[must_use]
pub const fn new(id: DeviceId) -> Self {
Self {
id,
channel: Channel::ONE,
now: 0,
timeout: DEFAULT_TIMEOUT_MS,
decoder: Decoder::new(),
tx: Queue::new(),
events: Queue::new(),
lost: 0,
pending: [const { None }; MAX_PENDING],
program: Known::Unknown,
identity: Known::Unknown,
nrpn: Nrpn::new(),
}
}
#[must_use]
pub const fn with_channel(mut self, channel: Channel) -> Self {
self.channel = channel;
self
}
#[must_use]
pub const fn with_timeout(mut self, milliseconds: u64) -> Self {
self.timeout = milliseconds;
self
}
#[must_use]
pub const fn id(&self) -> DeviceId {
self.id
}
#[must_use]
pub const fn channel(&self) -> Channel {
self.channel
}
#[must_use]
pub const fn now(&self) -> u64 {
self.now
}
#[must_use]
pub const fn program(&self) -> &Known<Program> {
&self.program
}
#[must_use]
pub const fn identity(&self) -> &Known<Identity> {
&self.identity
}
#[must_use]
pub fn firmware(&self) -> Version {
self.identity
.value()
.map_or(DEFAULT_FIRMWARE, |identity| identity.firmware)
}
#[must_use]
pub const fn timeout(&self) -> u64 {
self.timeout
}
pub fn outstanding(&self) -> impl Iterator<Item = Request> + '_ {
self.pending
.iter()
.filter_map(|slot| slot.map(|pending| pending.request))
}
#[must_use]
pub const fn queued(&self) -> usize {
self.tx.len()
}
#[must_use]
pub const fn room(&self) -> usize {
self.tx.remaining()
}
pub fn reset(&mut self) {
self.decoder.reset();
self.tx.clear();
self.events.clear();
self.lost = 0;
self.pending = [const { None }; MAX_PENDING];
self.program = Known::Unknown;
self.identity = Known::Unknown;
self.nrpn = Nrpn::new();
}
pub fn assume_program(&mut self, program: Program) {
self.program = Known::Assumed {
value: program,
at: self.now,
};
}
pub fn tick(&mut self, now_ms: u64) {
if now_ms < self.now {
return;
}
self.now = now_ms;
let Self {
timeout,
pending,
events,
lost,
..
} = self;
for slot in pending.iter_mut() {
let overdue =
slot.is_some_and(|entry| now_ms.saturating_sub(entry.sent_at) >= *timeout);
if !overdue {
continue;
}
if let Some(entry) = slot.take() {
enqueue(events, lost, Event::Timeout(entry.request));
}
}
}
pub fn poll_event(&mut self) -> Option<Event> {
if let Some(event) = self.events.pop() {
return Some(event);
}
let lost = core::mem::take(&mut self.lost);
(lost > 0).then_some(Event::Lost(lost))
}
pub fn feed(&mut self, bytes: &[u8]) {
let Self {
id,
channel,
now,
decoder,
events,
lost,
pending,
program,
identity,
nrpn,
..
} = self;
let mut inbound = Inbound {
id: *id,
channel: *channel,
now: *now,
events,
lost,
pending,
program,
identity,
nrpn,
};
decoder.feed(bytes, |event| inbound.handle(event));
}
pub fn drain_tx<E, F>(&mut self, mut send: F) -> core::result::Result<usize, E>
where
F: FnMut(&[u8]) -> core::result::Result<(), E>,
{
let mut count = 0;
while let Some(item) = self.tx.peek() {
let mut bytes = [0; MAX_OUTBOUND_LEN];
let written = match item.encode_into(self.id, self.channel, &mut bytes) {
Ok(written) => written,
Err(error) => {
self.tx.pop();
enqueue(&mut self.events, &mut self.lost, Event::Failed(error));
continue;
}
};
send(bytes.get(..written).unwrap_or_default())?;
self.tx.pop();
if let Some(request) = item.request() {
self.start(request);
}
count += 1;
}
Ok(count)
}
pub fn request_identity(&mut self) -> Result<()> {
self.ask(Request::Identity)
}
pub fn request_control_app(&mut self) -> Result<()> {
self.ask(Request::ControlApp)
}
pub fn request_edit_buffer(&mut self) -> Result<()> {
self.ask(Request::EditBuffer)
}
pub fn request_program(&mut self, slot: Slot) -> Result<()> {
self.ask(Request::Program(slot))
}
pub fn request_bank(
&mut self,
bank: Bank,
first: ProgramNumber,
last: ProgramNumber,
) -> Result<()> {
if last.get() < first.get() {
return Err(Error::EmptyRun {
first: first.get(),
last: last.get(),
});
}
self.ask(Request::Bank { bank, first, last })
}
pub fn edit<F>(&mut self, edit: F) -> Result<usize>
where
F: FnOnce(&mut Program),
{
let current = self.program.value().ok_or(Error::ProgramNotKnown)?;
let mut target = current.clone();
edit(&mut target);
let mut needed = 0;
for (parameter, value) in current.changes(&target) {
parameter.edit(u16::from(value))?;
needed += 1;
}
if needed == 0 {
return Ok(0);
}
let available = self.tx.remaining();
if needed > available {
return Err(Error::QueueFull { needed, available });
}
for (parameter, value) in current.changes(&target) {
if let Ok(message) = parameter.edit(u16::from(value)) {
self.tx.push(Outbound::Edit(message));
}
}
self.program = Known::Assumed {
value: target,
at: self.now,
};
Ok(needed)
}
fn ask(&mut self, request: Request) -> Result<()> {
if self.tx.push(Outbound::Ask(request)) {
Ok(())
} else {
Err(Error::QueueFull {
needed: 1,
available: 0,
})
}
}
fn start(&mut self, request: Request) {
let now = self.now;
let existing = self
.pending
.iter_mut()
.find(|slot| slot.is_some_and(|entry| entry.request == request));
if let Some(slot) = existing {
*slot = Some(Pending {
request,
sent_at: now,
});
return;
}
if let Some(slot) = self.pending.iter_mut().find(|slot| slot.is_none()) {
*slot = Some(Pending {
request,
sent_at: now,
});
}
}
}
fn enqueue<const EV: usize>(events: &mut Queue<Event, EV>, lost: &mut u16, event: Event) {
if !events.push(event) {
*lost = lost.saturating_add(1);
}
}
struct Inbound<'a, const EV: usize> {
id: DeviceId,
channel: Channel,
now: u64,
events: &'a mut Queue<Event, EV>,
lost: &'a mut u16,
pending: &'a mut [Option<Pending>; MAX_PENDING],
program: &'a mut Known<Program>,
identity: &'a mut Known<Identity>,
nrpn: &'a mut Nrpn,
}
impl<const EV: usize> Inbound<'_, EV> {
fn push(&mut self, event: Event) {
enqueue(self.events, self.lost, event);
}
fn handle(&mut self, event: core::result::Result<WireEvent<'_>, Error>) {
match event {
Ok(WireEvent::SysEx(bytes)) => self.sysex(bytes),
Ok(WireEvent::Channel { channel, message }) => self.channel(channel, message),
Ok(WireEvent::Realtime(_) | WireEvent::Common(_)) => {}
Err(error) => self.push(Event::Failed(error)),
}
}
fn sysex(&mut self, bytes: &[u8]) {
match Frame::parse(bytes) {
Ok(frame) => {
if self.id == DeviceId::Broadcast || frame.device.addresses(self.id) {
self.message(&frame.message);
}
}
Err(Error::Foreign {
manufacturer,
model,
}) => match inquiry::parse_reply(bytes) {
Ok(identity) => self.identity(identity),
Err(_) => self.push(Event::Foreign {
manufacturer,
model,
}),
},
Err(error) => self.push(Event::Failed(error)),
}
}
fn message(&mut self, message: &Message<'_>) {
match *message {
Message::EditBufferDumpResponse { version, packed } => {
match Program::from_packed(version, packed) {
Ok(program) => {
*self.program = Known::Confirmed {
value: program.clone(),
at: self.now,
};
self.resolve(|request| request == Request::EditBuffer);
self.push(Event::EditBuffer(program));
}
Err(error) => self.push(Event::Failed(error)),
}
}
Message::ProgramDumpResponse {
version,
bank,
program,
packed,
} => {
let slot = Slot::new(bank, program);
match Program::from_packed(version, packed) {
Ok(program) => {
self.arrived(slot);
self.push(Event::Program { slot, program });
}
Err(error) => self.push(Event::Failed(error)),
}
}
Message::ControlAppNotifyResponse {
rx_channel,
tx_channel,
interface,
bank,
program,
} => {
self.resolve(|request| request == Request::ControlApp);
self.push(Event::ControlApp(ControlApp {
rx_channel,
tx_channel,
interface,
bank,
program,
}));
}
_ => self.push(Event::Unhandled(message.command())),
}
}
fn identity(&mut self, identity: Identity) {
if self.id != DeviceId::Broadcast && !identity.device.addresses(self.id) {
return;
}
*self.identity = Known::Confirmed {
value: identity,
at: self.now,
};
self.resolve(|request| request == Request::Identity);
self.push(Event::Identity(identity));
}
fn channel(&mut self, channel: Channel, message: ChannelMessage) {
if !self.consumed(channel, message) {
self.push(Event::Channel { channel, message });
}
}
fn consumed(&mut self, channel: Channel, message: ChannelMessage) -> bool {
if channel != self.channel {
return false;
}
match message {
ChannelMessage::ControlChange { controller, value } => {
self.control_change(controller, value)
}
_ => false,
}
}
fn control_change(&mut self, controller: u8, value: u8) -> bool {
match self.nrpn.control_change(controller, value) {
Change::Ignored => false,
Change::Pending => true,
Change::Parameter {
parameter,
value,
exact,
} => {
self.parameter(parameter, value, exact);
true
}
}
}
fn parameter(&mut self, parameter: ParamId, value: u16, exact: bool) {
self.push(Event::Parameter { parameter, value });
let Ok(byte) = u8::try_from(value) else {
return;
};
let Some(current) = self.program.value_mut() else {
return;
};
if current.set(parameter, byte).is_err() {
return;
}
let now = self.now;
*self.program = match core::mem::take(self.program) {
Known::Confirmed { value, .. } if exact => Known::Confirmed { value, at: now },
Known::Confirmed { value, .. } | Known::Assumed { value, .. } => {
Known::Assumed { value, at: now }
}
Known::Unknown => Known::Unknown,
};
}
fn resolve<F: Fn(Request) -> bool>(&mut self, matches: F) {
if let Some(slot) = self
.pending
.iter_mut()
.find(|slot| slot.is_some_and(|entry| matches(entry.request)))
{
*slot = None;
}
}
fn arrived(&mut self, slot: Slot) {
let now = self.now;
for entry in self.pending.iter_mut() {
match *entry {
Some(Pending {
request: Request::Program(asked),
..
}) if asked == slot => {
*entry = None;
}
Some(Pending {
request: Request::Bank { bank, first, last },
..
}) if bank == slot.bank
&& (first.get()..=last.get()).contains(&slot.number.get()) =>
{
if slot.number.get() == last.get() {
*entry = None;
} else if let Some(pending) = entry.as_mut() {
pending.sent_at = now;
}
}
_ => {}
}
}
}
}
#[cfg(test)]
#[expect(
clippy::expect_used,
clippy::indexing_slicing,
clippy::panic,
reason = "a failed expectation is the test failure"
)]
mod tests {
use super::*;
use crate::ids::ProtocolVersion;
use crate::param::{DATA_ENTRY_LSB, DATA_ENTRY_MSB, NRPN_NUMBER_LSB, NRPN_NUMBER_MSB};
use crate::program::ProgramName;
use crate::sysex::{Command, Interface, inquiry};
use crate::testing::assert_display;
const FRAME: usize = 320;
struct Port {
bytes: [u8; 4096],
len: usize,
writes: usize,
}
impl Port {
const fn new() -> Self {
Self {
bytes: [0; 4096],
len: 0,
writes: 0,
}
}
fn send(&mut self, chunk: &[u8]) -> core::result::Result<(), ()> {
let end = self.len + chunk.len();
if end > self.bytes.len() {
return Err(());
}
self.bytes[self.len..end].copy_from_slice(chunk);
self.len = end;
self.writes += 1;
Ok(())
}
fn sent(&self) -> &[u8] {
&self.bytes[..self.len]
}
}
fn program(name: &str) -> Program {
let mut program = Program::new(ProtocolVersion::V6);
program.set_name(ProgramName::new(name).expect("a name the display can write"));
program
}
fn slot(bank: Bank, number: u8) -> Slot {
Slot::new(
bank,
ProgramNumber::new(number).expect("a program in range"),
)
}
fn frame<'a>(out: &'a mut [u8; FRAME], message: Message<'_>) -> &'a [u8] {
let len = Frame::new(DeviceId::Unit(0), message)
.encode_into(out)
.expect("the buffer fits");
&out[..len]
}
fn feed_edit_buffer<const RX: usize, const TX: usize, const EV: usize>(
device: &mut Device<RX, TX, EV>,
program: &Program,
) {
let mut packed = [0; Program::PACKED_MAX_LEN];
let len = program.pack_into(&mut packed).expect("the buffer fits");
let mut out = [0; FRAME];
device.feed(frame(
&mut out,
Message::EditBufferDumpResponse {
version: program.version(),
packed: &packed[..len],
},
));
}
fn feed_program<const RX: usize, const TX: usize, const EV: usize>(
device: &mut Device<RX, TX, EV>,
slot: Slot,
program: &Program,
) {
let mut packed = [0; Program::PACKED_MAX_LEN];
let len = program.pack_into(&mut packed).expect("the buffer fits");
let mut out = [0; FRAME];
device.feed(frame(
&mut out,
Message::ProgramDumpResponse {
version: program.version(),
bank: slot.bank,
program: slot.number,
packed: &packed[..len],
},
));
}
fn feed_cc<const RX: usize, const TX: usize, const EV: usize>(
device: &mut Device<RX, TX, EV>,
controller: u8,
value: u8,
) {
device.feed(&[0xB0, controller, value]);
}
fn drain(device: &mut Device) -> Port {
let mut port = Port::new();
device.drain_tx(|bytes| port.send(bytes)).unwrap_or(0);
port
}
fn events(device: &mut Device) -> impl Iterator<Item = Event> + '_ {
core::iter::from_fn(move || device.poll_event())
}
#[test]
fn a_request_is_bytes_only_once_it_is_drained() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.request_edit_buffer().expect("room in the queue");
assert_eq!(device.queued(), 1);
assert_eq!(device.outstanding().count(), 0, "queued is not sent");
let port = drain(&mut device);
assert_eq!(
port.sent(),
[0xF0, 0x00, 0x20, 0x32, 0x20, 0x00, 0x03, 0xF7]
);
assert_eq!(device.queued(), 0);
assert_eq!(
device.outstanding().next(),
Some(Request::EditBuffer),
"sent is outstanding"
);
}
#[test]
fn an_edit_buffer_dump_confirms_the_program_and_answers_the_request() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.request_edit_buffer().expect("room in the queue");
drain(&mut device);
assert_eq!(device.outstanding().count(), 1);
let sound = program("Bass Sweep");
feed_edit_buffer(&mut device, &sound);
assert!(matches!(device.poll_event(), Some(Event::EditBuffer(_))));
assert_eq!(device.poll_event(), None);
assert!(device.program().is_confirmed());
assert_eq!(
device.program().value().map(Program::name),
Some(sound.name())
);
assert_eq!(device.outstanding().count(), 0);
}
#[test]
fn the_same_bytes_arrive_the_same_way_one_at_a_time() {
let sound = program("Bass Sweep");
let mut packed = [0; Program::PACKED_MAX_LEN];
let len = sound.pack_into(&mut packed).expect("the buffer fits");
let mut out = [0; FRAME];
let bytes = frame(
&mut out,
Message::EditBufferDumpResponse {
version: sound.version(),
packed: &packed[..len],
},
);
let mut whole: Device = Device::new(DeviceId::Unit(0));
whole.feed(bytes);
let mut piecemeal: Device = Device::new(DeviceId::Unit(0));
for byte in bytes {
piecemeal.feed(&[*byte]);
}
assert_eq!(whole.program(), piecemeal.program());
assert!(whole.program().is_confirmed());
}
#[test]
fn a_request_that_goes_unanswered_times_out_once() {
let mut device: Device = Device::new(DeviceId::Unit(0)).with_timeout(100);
device.request_edit_buffer().expect("room in the queue");
drain(&mut device);
device.tick(99);
assert_eq!(device.poll_event(), None, "not overdue yet");
device.tick(100);
assert_eq!(
device.poll_event(),
Some(Event::Timeout(Request::EditBuffer))
);
device.tick(10_000);
assert_eq!(device.poll_event(), None, "raised once, then forgotten");
}
#[test]
fn a_request_never_drained_never_times_out() {
let mut device: Device = Device::new(DeviceId::Unit(0)).with_timeout(100);
device.request_edit_buffer().expect("room in the queue");
device.tick(10_000);
assert_eq!(device.poll_event(), None);
assert_eq!(device.queued(), 1, "still waiting to be sent");
}
#[test]
fn a_clock_that_goes_backwards_is_ignored() {
let mut device: Device = Device::new(DeviceId::Unit(0)).with_timeout(100);
device.tick(1_000);
device.tick(10);
assert_eq!(device.now(), 1_000);
}
#[test]
fn editing_before_anything_is_known_says_so() {
let mut device: Device = Device::new(DeviceId::Unit(0));
assert_eq!(
device.edit(|program| program.set_lfo1_rate(64)),
Err(Error::ProgramNotKnown)
);
}
#[test]
fn an_edit_sends_one_message_for_each_parameter_that_changed() {
let mut device: Device = Device::new(DeviceId::Unit(0));
feed_edit_buffer(&mut device, &program("Bass Sweep"));
while device.poll_event().is_some() {}
let changed = device
.edit(|program| {
program.set_lfo1_rate(64);
program.set_lfo1_rate(65);
let was = program.vcf_frequency();
program.set_vcf_frequency(was);
})
.expect("a program to diff against");
assert_eq!(changed, 1, "two writes to one parameter, one message");
let port = drain(&mut device);
assert_eq!(
port.sent(),
[0xB0, 99, 0, 0xB0, 98, 0, 0xB0, 6, 0, 0xB0, 38, 65]
);
assert_eq!(port.writes, 1, "one call per message");
assert!(device.program().is_assumed(), "sent, not confirmed");
}
#[test]
fn an_edit_that_changes_nothing_sends_nothing() {
let mut device: Device = Device::new(DeviceId::Unit(0));
feed_edit_buffer(&mut device, &program("Bass Sweep"));
while device.poll_event().is_some() {}
assert_eq!(device.edit(|_| {}), Ok(0));
assert_eq!(device.queued(), 0);
assert!(device.program().is_confirmed(), "still nothing sent");
}
#[test]
fn an_edit_too_big_for_the_queue_queues_none_of_it() {
let mut device: Device<MAX_SYSEX_LEN, 1, 4> = Device::new(DeviceId::Unit(0));
feed_edit_buffer(&mut device, &program("Bass Sweep"));
while device.poll_event().is_some() {}
let outcome = device.edit(|program| {
program.set_lfo1_rate(64);
program.set_lfo2_rate(64);
});
assert_eq!(
outcome,
Err(Error::QueueFull {
needed: 2,
available: 1
})
);
assert_eq!(device.queued(), 0, "nothing half-sent");
assert!(device.program().is_confirmed(), "and nothing assumed");
}
#[test]
fn an_nrpn_from_the_synthesizer_keeps_the_program_confirmed() {
let mut device: Device = Device::new(DeviceId::Unit(0));
feed_edit_buffer(&mut device, &program("Bass Sweep"));
while device.poll_event().is_some() {}
feed_cc(&mut device, NRPN_NUMBER_MSB, 0);
feed_cc(&mut device, NRPN_NUMBER_LSB, ParamId::Lfo1Rate.offset());
feed_cc(&mut device, DATA_ENTRY_MSB, 0);
feed_cc(&mut device, DATA_ENTRY_LSB, 99);
assert_eq!(
device.poll_event(),
Some(Event::Parameter {
parameter: ParamId::Lfo1Rate,
value: 99
})
);
assert_eq!(device.poll_event(), None, "the selection is not an event");
assert!(device.program().is_confirmed(), "the whole value arrived");
assert_eq!(device.program().value().map(Program::lfo1_rate), Some(99),);
}
#[test]
fn a_selected_parameter_stays_selected_across_a_sweep() {
let mut device: Device = Device::new(DeviceId::Unit(0));
feed_edit_buffer(&mut device, &program("Bass Sweep"));
while device.poll_event().is_some() {}
feed_cc(&mut device, NRPN_NUMBER_MSB, 0);
feed_cc(&mut device, NRPN_NUMBER_LSB, ParamId::Lfo1Rate.offset());
for value in [10, 11, 12] {
feed_cc(&mut device, DATA_ENTRY_MSB, 0);
feed_cc(&mut device, DATA_ENTRY_LSB, value);
}
let seen: usize = events(&mut device)
.filter(|event| matches!(event, Event::Parameter { .. }))
.count();
assert_eq!(seen, 3);
assert_eq!(device.program().value().map(Program::lfo1_rate), Some(12));
}
#[test]
fn a_controller_carries_seven_bits_so_the_program_becomes_assumed() {
let mut device: Device = Device::new(DeviceId::Unit(0));
feed_edit_buffer(&mut device, &program("Bass Sweep"));
while device.poll_event().is_some() {}
feed_cc(&mut device, 16, 64);
let expected = ParamId::Lfo1Rate.from_cc_value(64);
assert_eq!(
device.poll_event(),
Some(Event::Parameter {
parameter: ParamId::Lfo1Rate,
value: expected
})
);
assert!(
device.program().is_assumed(),
"a controller does not confirm a value it cannot carry"
);
}
#[test]
fn a_message_on_another_channel_is_reported_and_not_applied() {
let mut device: Device = Device::new(DeviceId::Unit(0));
feed_edit_buffer(&mut device, &program("Bass Sweep"));
while device.poll_event().is_some() {}
let before = device.program().clone();
device.feed(&[0xB1, 16, 64]);
assert!(matches!(device.poll_event(), Some(Event::Channel { .. })));
assert_eq!(device.program(), &before);
}
#[test]
fn a_note_is_reported_rather_than_swallowed() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.feed(&[0x90, 60, 100]);
assert!(matches!(device.poll_event(), Some(Event::Channel { .. })));
}
#[test]
fn a_running_clock_is_not_an_event() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.feed(&[0xF8; 64]);
assert_eq!(device.poll_event(), None);
}
#[test]
fn a_stored_program_is_reported_and_not_tracked() {
let mut device: Device = Device::new(DeviceId::Unit(0));
let target = slot(Bank::from_letter('B').expect("a bank letter"), 4);
device.request_program(target).expect("room in the queue");
drain(&mut device);
feed_program(&mut device, target, &program("Lead"));
match device.poll_event() {
Some(Event::Program { slot, program }) => {
assert_eq!(slot, target);
assert_eq!(program.name().as_str(), "Lead");
}
other => panic!("expected a program dump, got {other:?}"),
}
assert!(
device.program().is_unknown(),
"a stored program is not the sound it is making"
);
assert_eq!(device.outstanding().count(), 0);
}
#[test]
fn a_bank_request_ends_on_its_last_program() {
let mut device: Device = Device::new(DeviceId::Unit(0)).with_timeout(100);
let first = ProgramNumber::new(0).expect("a program in range");
let last = ProgramNumber::new(2).expect("a program in range");
device
.request_bank(Bank::A, first, last)
.expect("room in the queue");
drain(&mut device);
let sound = program("Lead");
for number in 0..=1 {
device.tick(u64::from(number) * 90);
feed_program(&mut device, slot(Bank::A, number), &sound);
assert_eq!(
device.outstanding().count(),
1,
"a dump inside the run is progress, not an answer"
);
}
device.tick(180);
assert_eq!(device.outstanding().count(), 1, "and it stays progress");
feed_program(&mut device, slot(Bank::A, 2), &sound);
assert_eq!(device.outstanding().count(), 0);
}
#[test]
fn one_dump_answers_every_request_it_fits() {
let mut device: Device = Device::new(DeviceId::Unit(0)).with_timeout(100);
let first = ProgramNumber::new(0).expect("a program in range");
let last = ProgramNumber::new(1).expect("a program in range");
device.request_program(slot(Bank::A, 1)).expect("room");
device.request_bank(Bank::A, first, last).expect("room");
drain(&mut device);
assert_eq!(device.outstanding().count(), 2);
let sound = program("Lead");
feed_program(&mut device, slot(Bank::A, 0), &sound);
assert_eq!(device.outstanding().count(), 2, "progress on the run");
feed_program(&mut device, slot(Bank::A, 1), &sound);
assert_eq!(device.outstanding().count(), 0, "both were answered");
}
#[test]
fn a_bank_request_before_a_late_program_is_rejected() {
let mut device: Device = Device::new(DeviceId::Unit(0));
let first = ProgramNumber::new(4).expect("a program in range");
let last = ProgramNumber::new(2).expect("a program in range");
assert_eq!(
device.request_bank(Bank::A, first, last),
Err(Error::EmptyRun { first: 4, last: 2 })
);
}
#[test]
fn a_device_inquiry_reply_reports_firmware() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.request_identity().expect("room in the queue");
drain(&mut device);
let identity = Identity {
device: DeviceId::Unit(0),
firmware: inquiry::Version { major: 1, minor: 1 },
voice: inquiry::Version { major: 1, minor: 0 },
};
let mut reply = [0; inquiry::REPLY_LEN];
inquiry::reply_into(&identity, &mut reply).expect("the buffer fits");
device.feed(&reply);
assert_eq!(device.poll_event(), Some(Event::Identity(identity)));
assert!(device.identity().is_confirmed());
assert_eq!(device.firmware(), identity.firmware);
assert_eq!(device.outstanding().count(), 0);
}
#[test]
fn another_units_inquiry_reply_is_that_units_answer() {
let mut device: Device = Device::new(DeviceId::Unit(0));
let identity = Identity {
device: DeviceId::Unit(1),
firmware: inquiry::Version { major: 1, minor: 1 },
voice: inquiry::Version { major: 1, minor: 0 },
};
let mut reply = [0; inquiry::REPLY_LEN];
inquiry::reply_into(&identity, &mut reply).expect("the buffer fits");
device.feed(&reply);
assert_eq!(device.poll_event(), None);
assert!(device.identity().is_unknown());
}
#[test]
fn a_control_app_reply_reports_what_the_interface_holds() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.request_control_app().expect("room in the queue");
drain(&mut device);
assert_eq!(
device.outstanding().next(),
Some(Request::ControlApp),
"announcing the host is a request like any other"
);
let mut out = [0; FRAME];
device.feed(frame(
&mut out,
Message::ControlAppNotifyResponse {
rx_channel: 1,
tx_channel: 0,
interface: Interface::Usb,
bank: Bank::from_letter('C').expect("C is a bank"),
program: ProgramNumber::new(40).expect("a program in a bank"),
},
));
let Some(Event::ControlApp(answer)) = device.poll_event() else {
panic!("the only message that names the selected program was dropped");
};
assert_display(answer.slot(), "C41");
assert_eq!(answer.interface, Interface::Usb);
assert_eq!(answer.receive_channel(), Some(Channel::ONE));
assert_eq!(answer.transmit_channel(), Some(Channel::ONE));
assert_eq!(device.outstanding().count(), 0, "the request was answered");
}
#[test]
fn a_control_app_reply_leaves_the_tracked_program_alone() {
let mut device: Device = Device::new(DeviceId::Unit(0));
feed_edit_buffer(&mut device, &program("Bass Sweep"));
while device.poll_event().is_some() {}
let mut out = [0; FRAME];
device.feed(frame(
&mut out,
Message::ControlAppNotifyResponse {
rx_channel: 0,
tx_channel: 0,
interface: Interface::Midi,
bank: Bank::A,
program: ProgramNumber::FIRST,
},
));
assert!(matches!(device.poll_event(), Some(Event::ControlApp(_))));
assert!(device.program().is_confirmed());
assert_eq!(
device.program().value().map(Program::name),
Some(ProgramName::new("Bass Sweep").expect("a name the display can write"))
);
}
#[test]
fn an_unanswered_control_app_notification_times_out_like_the_rest() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.request_control_app().expect("room in the queue");
drain(&mut device);
device.tick(DEFAULT_TIMEOUT_MS);
assert_eq!(
device.poll_event(),
Some(Event::Timeout(Request::ControlApp))
);
assert_eq!(device.outstanding().count(), 0);
}
#[test]
fn a_control_app_notification_is_the_frame_the_manual_prints() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.request_control_app().expect("room in the queue");
let mut port = Port::new();
device
.drain_tx(|bytes| port.send(bytes))
.expect("the port took it");
assert_eq!(
port.sent(),
&[0xF0, 0x00, 0x20, 0x32, 0x20, 0x00, 0x00, 0x00, 0xF7]
);
}
#[test]
fn the_firmware_is_the_current_one_until_the_synthesizer_says_otherwise() {
let device: Device = Device::new(DeviceId::Unit(0));
assert_eq!(device.firmware(), DEFAULT_FIRMWARE);
}
#[test]
fn another_manufacturers_frame_is_reported_as_theirs() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.feed(&[0xF0, 0x43, 0x00, 0x00, 0x01, 0x00, 0x00, 0xF7]);
assert_eq!(
device.poll_event(),
Some(Event::Foreign {
manufacturer: [0x43, 0x00, 0x00],
model: 0x01
})
);
}
#[test]
fn a_frame_for_another_unit_is_not_this_devices_business() {
let mut device: Device = Device::new(DeviceId::Unit(1));
feed_edit_buffer(&mut device, &program("Bass Sweep"));
assert_eq!(device.poll_event(), None);
assert!(device.program().is_unknown());
}
#[test]
fn a_broadcast_host_listens_to_every_unit() {
let mut device: Device = Device::new(DeviceId::Broadcast);
feed_edit_buffer(&mut device, &program("Bass Sweep"));
assert!(matches!(device.poll_event(), Some(Event::EditBuffer(_))));
}
#[test]
fn a_message_this_layer_does_not_track_is_still_reported() {
let mut device: Device = Device::new(DeviceId::Unit(0));
let mut out = [0; FRAME];
device.feed(frame(&mut out, Message::ChordMemoryDumpRequest));
assert_eq!(
device.poll_event(),
Some(Event::Unhandled(Command::ChordMemoryDumpRequest))
);
}
#[test]
fn an_unreadable_frame_is_reported_with_its_reason() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.feed(&[0xF0, 0x00, 0x20, 0x32, 0x20, 0x00, 0x7E, 0xF7]);
assert_eq!(
device.poll_event(),
Some(Event::Failed(Error::UnknownCommand(0x7E)))
);
}
#[test]
fn events_that_do_not_fit_are_counted_and_reported() {
let mut device: Device<MAX_SYSEX_LEN, 8, 2> = Device::new(DeviceId::Unit(0));
for _ in 0..5 {
device.feed(&[0x90, 60, 100]);
}
assert!(matches!(device.poll_event(), Some(Event::Channel { .. })));
assert!(matches!(device.poll_event(), Some(Event::Channel { .. })));
assert_eq!(device.poll_event(), Some(Event::Lost(3)));
assert_eq!(device.poll_event(), None);
}
#[test]
fn a_port_that_refuses_keeps_everything_queued() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.request_identity().expect("room in the queue");
device.request_edit_buffer().expect("room in the queue");
let outcome: core::result::Result<usize, ()> = device.drain_tx(|_| Err(()));
assert_eq!(outcome, Err(()));
assert_eq!(device.queued(), 2, "the refused item stays first");
assert_eq!(device.outstanding().count(), 0, "nothing went out");
}
#[test]
fn a_full_outbound_queue_says_so() {
let mut device: Device<MAX_SYSEX_LEN, 1, 2> = Device::new(DeviceId::Unit(0));
device.request_identity().expect("room in the queue");
assert_eq!(
device.request_edit_buffer(),
Err(Error::QueueFull {
needed: 1,
available: 0
})
);
}
#[test]
fn a_seeded_program_is_assumed_and_sends_nothing() {
let mut device: Device = Device::new(DeviceId::Unit(0));
device.assume_program(program("From A File"));
assert!(device.program().is_assumed());
assert_eq!(device.queued(), 0);
assert_eq!(device.edit(|program| program.set_lfo1_rate(64)), Ok(1));
}
#[test]
fn a_reset_forgets_everything() {
let mut device: Device = Device::new(DeviceId::Unit(0)).with_timeout(100);
device.request_edit_buffer().expect("room in the queue");
drain(&mut device);
feed_edit_buffer(&mut device, &program("Bass Sweep"));
device.feed(&[0x90, 60]);
device.reset();
assert!(device.program().is_unknown());
assert!(device.identity().is_unknown());
assert_eq!(device.queued(), 0);
assert_eq!(device.poll_event(), None);
assert_eq!(device.outstanding().count(), 0);
device.tick(10_000);
assert_eq!(device.poll_event(), None);
}
#[test]
fn the_channel_an_edit_goes_out_on_is_the_one_it_was_given() {
let channel = Channel::new(3).expect("a channel in range");
let mut device: Device = Device::new(DeviceId::Unit(0)).with_channel(channel);
device.assume_program(program("Bass Sweep"));
device
.edit(|program| program.set_lfo1_rate(1))
.expect("a program to diff against");
let port = drain(&mut device);
assert_eq!(port.sent().first(), Some(&0xB3));
assert_eq!(device.channel(), channel);
}
}