809 lines
26 KiB
Rust
809 lines
26 KiB
Rust
use fader_config::{
|
|
Action, MessageKind, MixerLayoutEntry, ProfileDocument, SelectorDraft, SelectorField,
|
|
SelectorPattern, TargetKind,
|
|
};
|
|
|
|
const PROFILE: &str = include_str!("../../examples/profiles/desktop.toml");
|
|
|
|
#[test]
|
|
fn removing_a_surface_clears_its_bindings_and_default_controller_atomically() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
|
|
draft.remove_surface("desk-left").unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
assert!(profile.surfaces().is_empty());
|
|
assert!(profile.bindings().is_empty());
|
|
assert_eq!(profile.default_controller(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn target_labels_can_be_renamed_without_changing_routing() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
|
|
draft.set_application_label("music", "Listening").unwrap();
|
|
draft.set_group_label("media", "Entertainment").unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
assert_eq!(profile.applications()[0].label(), "Listening");
|
|
assert_eq!(profile.groups()[0].label(), "Entertainment");
|
|
assert_eq!(profile.groups()[0].members(), &["music", "browser"]);
|
|
assert_eq!(profile.faders()[0].target_id(), "media");
|
|
assert_eq!(profile.bindings().len(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn binding_edits_materialize_an_omitted_optional_binding_array() {
|
|
let source = PROFILE.split("[[bindings]]").next().unwrap();
|
|
assert!(ProfileDocument::parse(&format!("{source}\n[bindings]\n")).is_err());
|
|
let mut draft = ProfileDocument::parse(source).unwrap();
|
|
|
|
draft
|
|
.remove_bindings("media-fader", Action::Volume)
|
|
.unwrap();
|
|
draft
|
|
.set_binding(
|
|
"desk-left",
|
|
"media-fader",
|
|
Action::Volume,
|
|
MessageKind::Cc,
|
|
1,
|
|
7,
|
|
)
|
|
.unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
assert_eq!(profile.bindings().len(), 1);
|
|
assert_eq!(profile.bindings()[0].fader(), "media-fader");
|
|
}
|
|
|
|
#[test]
|
|
fn object_edits_materialize_omitted_optional_arrays() {
|
|
let mut draft = ProfileDocument::parse(
|
|
r#"schema_version = 1
|
|
id = "minimal"
|
|
startup = "adopt"
|
|
new_stream = "adopt"
|
|
|
|
[audio]
|
|
adapter = "auto"
|
|
preference = ["pulse", "pipewire"]
|
|
max_gain = 1.0
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
draft
|
|
.add_application(
|
|
"music",
|
|
"Music",
|
|
&[SelectorDraft {
|
|
field: SelectorField::ApplicationName,
|
|
pattern: SelectorPattern::Exact("Music Player".into()),
|
|
}],
|
|
)
|
|
.unwrap();
|
|
draft.add_group("media", "Media", &["music"]).unwrap();
|
|
draft
|
|
.add_fader("media-fader", TargetKind::Group, "media", true, 0.02)
|
|
.unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
assert_eq!(profile.applications()[0].id(), "music");
|
|
assert_eq!(profile.groups()[0].id(), "media");
|
|
assert_eq!(profile.faders()[0].id(), "media-fader");
|
|
}
|
|
|
|
#[test]
|
|
fn mixer_objects_are_created_and_removed_as_atomic_valid_units() {
|
|
let mut draft = ProfileDocument::empty("default").unwrap();
|
|
draft
|
|
.add_application_fader(
|
|
"chat",
|
|
"Chat",
|
|
&SelectorDraft {
|
|
field: SelectorField::ApplicationName,
|
|
pattern: SelectorPattern::Exact("__unconfigured_chat__".into()),
|
|
},
|
|
"chat-fader",
|
|
0,
|
|
)
|
|
.unwrap();
|
|
draft
|
|
.add_group_fader("players", "Players", "players-fader", 1)
|
|
.unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
assert_eq!(profile.applications()[0].id(), "chat");
|
|
assert!(profile.groups()[0].members().is_empty());
|
|
assert_eq!(profile.faders().len(), 3);
|
|
assert!(matches!(
|
|
&profile.mixer_layout()[0],
|
|
MixerLayoutEntry::Fader { fader, .. } if fader == "chat-fader"
|
|
));
|
|
assert!(matches!(
|
|
&profile.mixer_layout()[1],
|
|
MixerLayoutEntry::Fader { fader, .. } if fader == "players-fader"
|
|
));
|
|
|
|
draft.remove_mixer_fader("chat-fader").unwrap();
|
|
draft.remove_mixer_fader("players-fader").unwrap();
|
|
let profile = draft.preview().unwrap();
|
|
assert!(profile.applications().is_empty());
|
|
assert!(profile.groups().is_empty());
|
|
assert_eq!(profile.faders().len(), 1);
|
|
assert_eq!(profile.faders()[0].id(), "master-fader");
|
|
}
|
|
|
|
#[test]
|
|
fn unnamed_separators_can_be_created_renamed_and_reloaded() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
draft.add_separator("spacer", "", 0).unwrap();
|
|
draft.add_separator("divider", "Divider", 1).unwrap();
|
|
draft.set_separator_label("divider", "").unwrap();
|
|
let reloaded = ProfileDocument::parse(&draft.finish().unwrap()).unwrap();
|
|
let profile = reloaded.preview().unwrap();
|
|
for entry in &profile.mixer_layout()[..2] {
|
|
assert!(matches!(entry, MixerLayoutEntry::Separator { label, .. } if label.is_empty()));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn separator_presentation_round_trips_without_changing_order() {
|
|
use fader_config::{SeparatorDecoration, SeparatorSize};
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
draft.add_separator("heading", "Heading", 0).unwrap();
|
|
draft
|
|
.set_separator_presentation("heading", SeparatorSize::Fill, SeparatorDecoration::Double)
|
|
.unwrap();
|
|
let draft = ProfileDocument::parse(&draft.finish().unwrap()).unwrap();
|
|
assert!(matches!(
|
|
&draft.preview().unwrap().mixer_layout()[0],
|
|
MixerLayoutEntry::Separator {
|
|
size: SeparatorSize::Fill,
|
|
decoration: SeparatorDecoration::Double,
|
|
..
|
|
}
|
|
));
|
|
assert!(
|
|
fader_config::Profile::parse(&draft.source().replace("size = \"fill\"", "size = \"huge\""))
|
|
.is_err()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn default_note_feedback_preserves_address_and_allows_configured_protocols() {
|
|
let mut draft = ProfileDocument::empty("fresh").unwrap();
|
|
draft
|
|
.add_surface(
|
|
"controller",
|
|
"Controller",
|
|
"Controller MIDI",
|
|
Some("Controller MIDI"),
|
|
None,
|
|
None,
|
|
None,
|
|
None,
|
|
None,
|
|
)
|
|
.unwrap();
|
|
for (kind, channel, number, supported) in [
|
|
(MessageKind::Note, 1, 0, true),
|
|
(MessageKind::Note, 1, 64, true),
|
|
(MessageKind::Note, 1, 71, true),
|
|
(MessageKind::Note, 1, 72, true),
|
|
(MessageKind::Note, 1, 82, true),
|
|
(MessageKind::Note, 1, 89, true),
|
|
(MessageKind::Note, 1, 98, true),
|
|
(MessageKind::Note, 2, 64, true),
|
|
(MessageKind::Note, 16, 127, true),
|
|
(MessageKind::Cc, 1, 64, false),
|
|
] {
|
|
draft
|
|
.set_binding(
|
|
"controller",
|
|
"master-fader",
|
|
Action::ToggleMute,
|
|
kind,
|
|
channel,
|
|
number,
|
|
)
|
|
.unwrap();
|
|
let profile = draft.preview().unwrap();
|
|
let feedback = profile.effective_feedback(&profile.bindings()[0]);
|
|
assert_eq!(feedback.is_some(), supported);
|
|
if let Some(feedback) = feedback {
|
|
assert_eq!(
|
|
(
|
|
feedback.channel(),
|
|
feedback.number(),
|
|
feedback.on(),
|
|
feedback.off()
|
|
),
|
|
(channel, number, 127, 0)
|
|
);
|
|
}
|
|
}
|
|
draft
|
|
.set_binding(
|
|
"controller",
|
|
"master-fader",
|
|
Action::ToggleMute,
|
|
MessageKind::Note,
|
|
1,
|
|
64,
|
|
)
|
|
.unwrap();
|
|
let source = draft.source();
|
|
for unsupported in [
|
|
source.replace("output_port = \"Controller MIDI\"", ""),
|
|
source
|
|
.replace("action = \"toggle_mute\"", "action = \"volume\"")
|
|
.replace("kind = \"note\"", "kind = \"cc\"")
|
|
.replace("edge = \"press\"", ""),
|
|
] {
|
|
let profile = fader_config::Profile::parse(&unsupported).unwrap();
|
|
assert!(profile.effective_feedback(&profile.bindings()[0]).is_none());
|
|
}
|
|
let explicit = format!(
|
|
"{source}\nfeedback = {{ kind = \"cc\", channel = 3, number = 65, on = 3, off = 2 }}\n"
|
|
);
|
|
let profile = fader_config::Profile::parse(&explicit).unwrap();
|
|
let feedback = profile.effective_feedback(&profile.bindings()[0]).unwrap();
|
|
assert_eq!((feedback.number(), feedback.on()), (65, 3));
|
|
assert_eq!(
|
|
(feedback.message_kind(), feedback.channel(), feedback.off()),
|
|
(MessageKind::Cc, 3, 2)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn draft_adds_a_discovered_midi_surface_with_durable_identity() {
|
|
let mut draft = ProfileDocument::empty("default").unwrap();
|
|
draft
|
|
.add_surface(
|
|
"apc-mini",
|
|
"APC MINI",
|
|
"APC MINI:APC MINI MIDI 1",
|
|
Some("APC MINI:APC MINI MIDI 1"),
|
|
Some("09e8"),
|
|
Some("0028"),
|
|
Some("Ver00.10"),
|
|
Some("pci-0000:00:14.0-usb-0:1"),
|
|
Some("36:0"),
|
|
)
|
|
.unwrap();
|
|
draft.set_default_controller(Some("apc-mini")).unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
let surface = &profile.surfaces()[0];
|
|
assert_eq!(surface.id(), "apc-mini");
|
|
assert_eq!(surface.input_port(), "APC MINI:APC MINI MIDI 1");
|
|
assert_eq!(surface.output_port(), Some("APC MINI:APC MINI MIDI 1"));
|
|
assert_eq!(surface.usb_serial(), Some("Ver00.10"));
|
|
assert_eq!(surface.manual_backend_id(), Some("36:0"));
|
|
assert_eq!(profile.default_controller(), Some("apc-mini"));
|
|
}
|
|
|
|
#[test]
|
|
fn draft_creates_an_application_group_and_fader_as_valid_toml() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
draft
|
|
.add_application(
|
|
"chat",
|
|
"Chat",
|
|
&[SelectorDraft {
|
|
field: SelectorField::ProcessBinary,
|
|
pattern: SelectorPattern::Exact("signal-desktop".to_owned()),
|
|
}],
|
|
)
|
|
.unwrap();
|
|
draft
|
|
.add_group("communications", "Communications", &["chat", "browser"])
|
|
.unwrap();
|
|
draft
|
|
.add_fader(
|
|
"communications-fader",
|
|
TargetKind::Group,
|
|
"communications",
|
|
true,
|
|
0.02,
|
|
)
|
|
.unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
assert!(
|
|
profile
|
|
.applications()
|
|
.iter()
|
|
.any(|item| item.id() == "chat")
|
|
);
|
|
assert!(
|
|
profile
|
|
.groups()
|
|
.iter()
|
|
.any(|item| item.id() == "communications")
|
|
);
|
|
assert!(
|
|
profile
|
|
.faders()
|
|
.iter()
|
|
.any(|item| item.id() == "communications-fader")
|
|
);
|
|
ProfileDocument::parse(&draft.finish().unwrap()).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_edits_and_referenced_deletes_roll_back_the_draft() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
let original = draft.source();
|
|
|
|
let invalid = draft
|
|
.add_application(
|
|
"broken",
|
|
"Broken",
|
|
&[SelectorDraft {
|
|
field: SelectorField::ApplicationName,
|
|
pattern: SelectorPattern::Regex("(".to_owned()),
|
|
}],
|
|
)
|
|
.unwrap_err();
|
|
assert!(invalid.to_string().contains("regex"));
|
|
assert_eq!(draft.source(), original);
|
|
|
|
let referenced = draft.remove_application("browser").unwrap_err();
|
|
assert!(referenced.to_string().contains("unknown application"));
|
|
assert_eq!(draft.source(), original);
|
|
}
|
|
|
|
#[test]
|
|
fn existing_applications_groups_and_faders_can_be_edited_and_deleted() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
draft
|
|
.set_application(
|
|
"browser",
|
|
"Web",
|
|
&[SelectorDraft {
|
|
field: SelectorField::ProcessBinary,
|
|
pattern: SelectorPattern::Exact("waterfox-bin".to_owned()),
|
|
}],
|
|
)
|
|
.unwrap();
|
|
draft.set_group("media", "Players", &["browser"]).unwrap();
|
|
draft
|
|
.set_fader(
|
|
"media-fader",
|
|
TargetKind::Application,
|
|
"browser",
|
|
false,
|
|
0.05,
|
|
)
|
|
.unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
assert_eq!(profile.applications()[1].label(), "Web");
|
|
assert_eq!(profile.groups()[0].members(), &["browser"]);
|
|
assert_eq!(profile.faders()[0].target_kind(), TargetKind::Application);
|
|
assert!(!profile.faders()[0].pickup());
|
|
|
|
draft.remove_group("media").unwrap();
|
|
draft.remove_fader("media-fader").unwrap_err();
|
|
assert!(draft.source().contains("media-fader"));
|
|
}
|
|
|
|
#[test]
|
|
fn editing_group_members_preserves_the_configured_volume_mode_field() {
|
|
let source = PROFILE.replace(
|
|
"volume_mode = \"absolute\"",
|
|
"volume_mode = \"absolute\" # user-owned group mode",
|
|
);
|
|
let mut draft = ProfileDocument::parse(&source).unwrap();
|
|
|
|
draft.set_group("media", "Players", &["browser"]).unwrap();
|
|
|
|
assert!(
|
|
draft
|
|
.source()
|
|
.contains("volume_mode = \"absolute\" # user-owned group mode")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn draft_sets_and_unsets_the_default_controller() {
|
|
let source = PROFILE.replace("default_controller = \"desk-left\"\n", "");
|
|
let mut draft = ProfileDocument::parse(&source).unwrap();
|
|
draft.set_default_controller(Some("desk-left")).unwrap();
|
|
assert_eq!(
|
|
draft.preview().unwrap().default_controller(),
|
|
Some("desk-left")
|
|
);
|
|
|
|
let before_invalid = draft.source();
|
|
let error = draft.set_default_controller(Some("missing")).unwrap_err();
|
|
assert!(error.to_string().contains("unknown surface"));
|
|
assert_eq!(draft.source(), before_invalid);
|
|
|
|
draft.set_default_controller(None).unwrap();
|
|
assert_eq!(draft.preview().unwrap().default_controller(), None);
|
|
assert!(!draft.source().contains("default_controller"));
|
|
}
|
|
|
|
#[test]
|
|
fn draft_theme_edit_is_profile_backed() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
draft.set_theme(fader_config::UiTheme::Nord).unwrap();
|
|
assert_eq!(
|
|
draft.preview().unwrap().theme(),
|
|
fader_config::UiTheme::Nord
|
|
);
|
|
assert!(draft.source().contains("theme = \"nord\""));
|
|
}
|
|
|
|
#[test]
|
|
fn draft_status_display_edit_is_profile_backed() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
draft
|
|
.set_status_display(fader_config::StatusDisplayMode::Color)
|
|
.unwrap();
|
|
assert_eq!(
|
|
draft.preview().unwrap().status_display(),
|
|
fader_config::StatusDisplayMode::Color
|
|
);
|
|
assert!(draft.source().contains("status_display = \"color\""));
|
|
}
|
|
|
|
#[test]
|
|
fn draft_adds_bindings_and_rejects_duplicate_physical_controls() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
draft
|
|
.add_binding(
|
|
"desk-left",
|
|
"media-fader",
|
|
Action::Volume,
|
|
MessageKind::Cc,
|
|
1,
|
|
49,
|
|
)
|
|
.unwrap();
|
|
let before_duplicate = draft.source();
|
|
let error = draft
|
|
.add_binding(
|
|
"desk-left",
|
|
"media-fader",
|
|
Action::ToggleMute,
|
|
MessageKind::Cc,
|
|
1,
|
|
49,
|
|
)
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("duplicate physical binding"));
|
|
assert_eq!(draft.source(), before_duplicate);
|
|
}
|
|
|
|
#[test]
|
|
fn mixer_layout_draft_reorders_separators_and_retains_hidden_faders() {
|
|
let source = PROFILE.replacen(
|
|
"[[bindings]]",
|
|
"# separator comment must move with its entry\n[[mixer_layout]]\nkind = \"separator\"\nid = \"outputs\"\nlabel = \"Outputs\"\n\n[[bindings]]",
|
|
1,
|
|
);
|
|
let mut draft = ProfileDocument::parse(&source).unwrap();
|
|
draft
|
|
.set_mixer_orientation(fader_config::MixerOrientation::Horizontal)
|
|
.expect("mixer orientation must be editable");
|
|
draft
|
|
.set_fader_hidden("media-fader", true)
|
|
.expect("fader must be hidden without deletion");
|
|
draft
|
|
.set_fader_density("media-fader", fader_config::FaderDensity::Thick)
|
|
.expect("fader density must be editable");
|
|
// Real sessions reopen a saved layout: parsed tables retain source positions.
|
|
let saved = draft.finish().unwrap();
|
|
let mut draft = ProfileDocument::parse(&saved).unwrap();
|
|
draft
|
|
.move_layout_entry("media-fader", 0)
|
|
.expect("hidden fader must remain reorderable");
|
|
draft
|
|
.set_separator_label("outputs", "Main outputs")
|
|
.expect("separator label must be editable");
|
|
|
|
let profile = draft.preview().unwrap();
|
|
assert_eq!(
|
|
profile.mixer_orientation(),
|
|
fader_config::MixerOrientation::Horizontal
|
|
);
|
|
assert_eq!(
|
|
profile.mixer_layout(),
|
|
[
|
|
MixerLayoutEntry::Fader {
|
|
fader: "media-fader".to_owned(),
|
|
hidden: true,
|
|
density: fader_config::FaderDensity::Thick,
|
|
},
|
|
MixerLayoutEntry::Separator {
|
|
id: "outputs".to_owned(),
|
|
label: "Main outputs".to_owned(),
|
|
size: fader_config::SeparatorSize::Standard,
|
|
decoration: fader_config::SeparatorDecoration::Line,
|
|
},
|
|
]
|
|
);
|
|
assert_eq!(profile.faders().len(), 1, "hiding must not delete routing");
|
|
assert!(
|
|
draft
|
|
.source()
|
|
.contains("# separator comment must move with its entry")
|
|
);
|
|
|
|
draft.remove_separator("outputs").unwrap();
|
|
draft.set_fader_hidden("media-fader", false).unwrap();
|
|
assert_eq!(
|
|
draft.preview().unwrap().mixer_layout(),
|
|
[MixerLayoutEntry::Fader {
|
|
fader: "media-fader".to_owned(),
|
|
hidden: false,
|
|
density: fader_config::FaderDensity::Thick,
|
|
}]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn saved_layout_moves_and_insertions_survive_repeated_reloads() {
|
|
let source = format!(
|
|
"{PROFILE}\n\
|
|
[[faders]]\nid = \"other-fader\"\ntarget = {{ kind = \"group\", id = \"media\" }}\npickup = true\npickup_tolerance = 0.02\n\
|
|
# first fader comment\n[[mixer_layout]]\nkind = \"fader\"\nfader = \"media-fader\"\ndensity = \"slim\"\n\
|
|
# separator comment\n[[mixer_layout]]\nkind = \"separator\"\nid = \"heading\"\nlabel = \"Heading\"\n\
|
|
# hidden fader comment\n[[mixer_layout]]\nkind = \"fader\"\nfader = \"other-fader\"\nhidden = true\n"
|
|
);
|
|
let mut draft = ProfileDocument::parse(&source).unwrap();
|
|
let ids = |draft: &ProfileDocument| {
|
|
draft
|
|
.preview()
|
|
.unwrap()
|
|
.mixer_layout()
|
|
.iter()
|
|
.map(|entry| match entry {
|
|
MixerLayoutEntry::Fader { fader, .. } => fader.clone(),
|
|
MixerLayoutEntry::Separator { id, .. } => id.clone(),
|
|
})
|
|
.collect::<Vec<_>>()
|
|
};
|
|
for (id, position, expected) in [
|
|
("media-fader", 2, ["heading", "other-fader", "media-fader"]),
|
|
("media-fader", 0, ["media-fader", "heading", "other-fader"]),
|
|
("other-fader", 0, ["other-fader", "media-fader", "heading"]),
|
|
("heading", 1, ["other-fader", "heading", "media-fader"]),
|
|
] {
|
|
draft.move_layout_entry(id, position).unwrap();
|
|
assert_eq!(ids(&draft), expected);
|
|
draft = ProfileDocument::parse(&draft.finish().unwrap()).unwrap();
|
|
assert_eq!(ids(&draft), expected);
|
|
}
|
|
draft
|
|
.add_separator("new-heading", "New heading", 0)
|
|
.unwrap();
|
|
draft = ProfileDocument::parse(&draft.finish().unwrap()).unwrap();
|
|
assert_eq!(
|
|
ids(&draft),
|
|
["new-heading", "other-fader", "heading", "media-fader"]
|
|
);
|
|
let saved = draft.source();
|
|
for comment in [
|
|
"first fader comment",
|
|
"separator comment",
|
|
"hidden fader comment",
|
|
] {
|
|
assert_eq!(saved.matches(comment).count(), 1);
|
|
}
|
|
let profile = draft.preview().unwrap();
|
|
assert!(matches!(
|
|
&profile.mixer_layout()[1],
|
|
MixerLayoutEntry::Fader { hidden: true, .. }
|
|
));
|
|
assert!(matches!(
|
|
&profile.mixer_layout()[3],
|
|
MixerLayoutEntry::Fader {
|
|
density: fader_config::FaderDensity::Slim,
|
|
..
|
|
}
|
|
));
|
|
assert_eq!(
|
|
profile.bindings(),
|
|
fader_config::Profile::parse(PROFILE).unwrap().bindings()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn selector_and_binding_edits_preserve_unrelated_capture_and_actions() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
draft
|
|
.add_application(
|
|
"multi",
|
|
"Multi",
|
|
&[
|
|
SelectorDraft {
|
|
field: SelectorField::ApplicationName,
|
|
pattern: SelectorPattern::Exact("Old".to_owned()),
|
|
},
|
|
SelectorDraft {
|
|
field: SelectorField::MediaName,
|
|
pattern: SelectorPattern::Regex("keep-me".to_owned()),
|
|
},
|
|
],
|
|
)
|
|
.unwrap();
|
|
draft
|
|
.set_application_selector(
|
|
"multi",
|
|
0,
|
|
&SelectorDraft {
|
|
field: SelectorField::ProcessBinary,
|
|
pattern: SelectorPattern::Exact("player-bin".to_owned()),
|
|
},
|
|
)
|
|
.unwrap();
|
|
draft
|
|
.set_binding(
|
|
"desk-left",
|
|
"media-fader",
|
|
Action::Volume,
|
|
MessageKind::Cc,
|
|
1,
|
|
7,
|
|
)
|
|
.unwrap();
|
|
let before_conflict = draft.source();
|
|
let conflict = draft
|
|
.set_binding(
|
|
"desk-left",
|
|
"media-fader",
|
|
Action::ToggleMute,
|
|
MessageKind::Cc,
|
|
1,
|
|
7,
|
|
)
|
|
.unwrap_err();
|
|
assert!(conflict.to_string().contains("duplicate physical binding"));
|
|
assert_eq!(draft.source(), before_conflict);
|
|
draft
|
|
.remove_bindings("media-fader", Action::ToggleMute)
|
|
.unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
let multi = profile
|
|
.applications()
|
|
.iter()
|
|
.find(|application| application.id() == "multi")
|
|
.unwrap();
|
|
assert_eq!(multi.selectors().len(), 2);
|
|
assert_eq!(multi.selectors()[0].pattern(), ("player-bin", false));
|
|
assert_eq!(multi.selectors()[1].pattern(), ("keep-me", true));
|
|
assert!(profile.bindings().iter().any(|binding| {
|
|
binding.fader() == "media-fader"
|
|
&& binding.action() == Action::Volume
|
|
&& binding.number() == 7
|
|
}));
|
|
assert!(!profile.bindings().iter().any(|binding| {
|
|
binding.fader() == "media-fader" && binding.action() == Action::ToggleMute
|
|
}));
|
|
}
|
|
|
|
#[test]
|
|
fn changing_a_mute_binding_moves_its_feedback_to_the_new_control() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
draft
|
|
.set_binding(
|
|
"desk-left",
|
|
"media-fader",
|
|
Action::ToggleMute,
|
|
MessageKind::Note,
|
|
1,
|
|
41,
|
|
)
|
|
.unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
let binding = profile
|
|
.bindings()
|
|
.iter()
|
|
.find(|binding| binding.action() == Action::ToggleMute)
|
|
.unwrap();
|
|
assert_eq!(binding.number(), 41);
|
|
let feedback = binding.feedback().expect("existing feedback is retained");
|
|
assert_eq!(feedback.number(), 41);
|
|
assert_eq!((feedback.on(), feedback.off()), (127, 0));
|
|
|
|
let independently_mapped = PROFILE.replace(
|
|
"feedback = { kind = \"note\", channel = 1, number = 32, on = 127, off = 0 }",
|
|
"feedback = { kind = \"note\", channel = 1, number = 33, on = 127, off = 0 }",
|
|
);
|
|
let mut draft = ProfileDocument::parse(&independently_mapped).unwrap();
|
|
draft
|
|
.set_binding(
|
|
"desk-left",
|
|
"media-fader",
|
|
Action::ToggleMute,
|
|
MessageKind::Note,
|
|
1,
|
|
41,
|
|
)
|
|
.unwrap();
|
|
let profile = draft.preview().unwrap();
|
|
let feedback = profile
|
|
.bindings()
|
|
.iter()
|
|
.find(|binding| binding.action() == Action::ToggleMute)
|
|
.and_then(|binding| binding.feedback())
|
|
.unwrap();
|
|
assert_eq!(feedback.number(), 33);
|
|
}
|
|
|
|
#[test]
|
|
fn a_new_mute_binding_inherits_unambiguous_surface_feedback_values() {
|
|
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
|
|
draft
|
|
.add_fader("second-media-fader", TargetKind::Group, "media", true, 0.02)
|
|
.unwrap();
|
|
draft
|
|
.set_binding(
|
|
"desk-left",
|
|
"second-media-fader",
|
|
Action::ToggleMute,
|
|
MessageKind::Note,
|
|
1,
|
|
42,
|
|
)
|
|
.unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
let feedback = profile
|
|
.bindings()
|
|
.iter()
|
|
.find(|binding| binding.fader() == "second-media-fader")
|
|
.and_then(|binding| binding.feedback())
|
|
.expect("the established surface feedback convention is inherited");
|
|
assert_eq!(feedback.number(), 42);
|
|
assert_eq!((feedback.on(), feedback.off()), (127, 0));
|
|
}
|
|
|
|
#[test]
|
|
fn a_new_mute_binding_does_not_guess_between_conflicting_feedback_values() {
|
|
let source = format!(
|
|
"{PROFILE}\n\
|
|
[[faders]]\n\
|
|
id = \"alternate-media-fader\"\n\
|
|
target = {{ kind = \"group\", id = \"media\" }}\n\
|
|
pickup = true\n\
|
|
pickup_tolerance = 0.02\n\n\
|
|
[[bindings]]\n\
|
|
surface = \"desk-left\"\n\
|
|
fader = \"alternate-media-fader\"\n\
|
|
action = \"toggle_mute\"\n\
|
|
edge = \"press\"\n\
|
|
message = {{ kind = \"note\", channel = 1, number = 33 }}\n\
|
|
feedback = {{ kind = \"note\", channel = 1, number = 33, on = 1, off = 0 }}\n"
|
|
);
|
|
let mut draft = ProfileDocument::parse(&source).unwrap();
|
|
draft
|
|
.add_fader("third-media-fader", TargetKind::Group, "media", true, 0.02)
|
|
.unwrap();
|
|
draft
|
|
.set_binding(
|
|
"desk-left",
|
|
"third-media-fader",
|
|
Action::ToggleMute,
|
|
MessageKind::Note,
|
|
1,
|
|
42,
|
|
)
|
|
.unwrap();
|
|
|
|
let profile = draft.preview().unwrap();
|
|
let binding = profile
|
|
.bindings()
|
|
.iter()
|
|
.find(|binding| binding.fader() == "third-media-fader")
|
|
.unwrap();
|
|
assert!(binding.feedback().is_none());
|
|
}
|