f67d38b35cc5
explicit_targets_tests.rs
//! A caller that names its targets in the parameters (`clips`, `clip`, `item`, `items`) does not
//! need a selection: enablement is checked against the named targets. Without such parameters
//! (the menus, shortcuts and `engine.commands`) enablement is the selection's, as before.
use filmcraft_project::{ClipId, ItemId, TrackItem};
use serde_json::json;
use crate::{EngineError, Session};
fn demo() -> Session {
let mut s = Session::default();
s.execute("file.openDemoProject", json!({})).unwrap();
s.execute("sequence.linkedSelection", json!({"on": false})).unwrap();
s.state.selection.clear();
s.state.project_selection.clear();
s
}
fn item_named(s: &Session, name: &str) -> ItemId {
s.project.items.values().find(|i| i.name == name).map(|i| i.id).unwrap_or_else(|| panic!("no item {name}"))
}
fn v1(s: &Session) -> Vec<TrackItem> {
s.active_sequence().unwrap().video_tracks[0].items.clone()
}
fn a1(s: &Session) -> Vec<TrackItem> {
s.active_sequence().unwrap().audio_tracks[0].items.clone()
}
fn clip(s: &Session, id: ClipId) -> Option<TrackItem> {
s.active_sequence().unwrap().find_item(id).map(|(_, i)| i.clone())
}
fn disabled(r: crate::Result<serde_json::Value>) -> String {
match r {
Err(EngineError::Disabled(_, why)) => why,
other => panic!("expected a disabled command, got {other:?}"),
}
}
#[test]
fn replace_from_bin_takes_an_explicit_item_and_clips_without_any_selection() {
let mut s = demo();
let c = v1(&s)[0].clone();
let dunes = item_named(&s, "Desert_Dunes.mp4");
assert_ne!(c.item, dunes);
// nothing named, nothing selected: disabled, for the menus and for a caller alike
assert!(!s.is_enabled("clip.replaceFromBin"));
assert_eq!(disabled(s.execute("clip.replaceFromBin", json!({}))), "no clips selected");
// the clip is named but the replacement is not: still the Project panel's call
assert_eq!(disabled(s.execute("clip.replaceFromBin", json!({"clips": [c.id.0]}))), "select a clip in the Project panel");
// both named: runs with no timeline and no Project-panel selection
s.execute("clip.replaceFromBin", json!({"clips": [c.id.0], "item": dunes.0})).unwrap();
assert_eq!(clip(&s, c.id).unwrap().item, dunes);
assert!(s.state.selection.is_empty() && s.state.project_selection.is_empty(), "the selections are left as they were");
assert!(!s.is_enabled("clip.replaceFromBin"), "menu enablement still follows the selection");
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(clip(&s, c.id).unwrap().item, c.item);
// a timeline selection plus an explicit item (no Project-panel selection)
s.execute("timeline.select", json!({"clips": [c.id.0]})).unwrap();
s.execute("clip.replaceFromBin", json!({"item": dunes.0})).unwrap();
assert_eq!(clip(&s, c.id).unwrap().item, dunes);
}
#[test]
fn clip_commands_take_explicit_clips_without_a_selection() {
let mut s = demo();
let (a, b) = (v1(&s)[0].clone(), v1(&s)[1].clone());
for id in ["edit.clear", "edit.rippleDelete", "clip.audioGain", "edit.pasteAttributes", "clip.enable"] {
assert!(!s.is_enabled(id), "{id} is disabled without a selection");
assert!(matches!(s.execute(id, json!({})), Err(EngineError::Disabled(..))), "{id} with no parameters stays disabled");
}
// Clear
s.execute("edit.clear", json!({"clips": [a.id.0]})).unwrap();
assert!(clip(&s, a.id).is_none() && clip(&s, b.id).is_some());
s.execute("edit.undo", json!({})).unwrap();
assert!(clip(&s, a.id).is_some());
// Ripple Delete
let a_and_its_audio: Vec<u64> = s
.active_sequence()
.unwrap()
.all_tracks()
.flat_map(|t| &t.items)
.filter(|i| i.id == a.id || (i.link.is_some() && i.link == a.link))
.map(|i| i.id.0)
.collect();
s.execute("timeline.setTrack", json!({"track": "A2", "syncLock": false})).unwrap(); // the music on A2 would block the ripple
s.execute("edit.rippleDelete", json!({"clips": a_and_its_audio})).unwrap();
assert!(clip(&s, a.id).is_none());
assert_eq!(clip(&s, b.id).unwrap().start, a.start, "the next clip closes the gap");
s.execute("edit.undo", json!({})).unwrap();
// Audio Gain
let au = a1(&s)[0].clone();
s.execute("clip.audioGain", json!({"clips": [au.id.0], "mode": "set", "db": -6.0})).unwrap();
assert_eq!(clip(&s, au.id).unwrap().gain_db, -6.0);
// Enable
s.execute("clip.enable", json!({"clips": [a.id.0]})).unwrap();
assert!(!clip(&s, a.id).unwrap().enabled);
s.execute("edit.undo", json!({})).unwrap();
assert!(clip(&s, a.id).unwrap().enabled);
s.execute("edit.redo", json!({})).unwrap();
assert!(!clip(&s, a.id).unwrap().enabled);
// `clip.enable` documents `clips` only: a key it does not document is not a named target
assert_eq!(disabled(s.execute("clip.enable", json!({"clip": a.id.0}))), "no clips selected");
// Paste Attributes: naming the clips lifts only the selection condition, not the clipboard one
assert_eq!(disabled(s.execute("edit.pasteAttributes", json!({"clips": [b.id.0]}))), "copy a clip first");
s.execute("timeline.select", json!({"clips": [a.id.0]})).unwrap();
s.execute("edit.copy", json!({})).unwrap();
s.state.selection.clear();
s.execute("edit.pasteAttributes", json!({"clips": [b.id.0]})).unwrap();
assert!(s.state.selection.is_empty(), "the selection is left as it was");
for id in ["edit.clear", "edit.rippleDelete", "clip.audioGain", "edit.pasteAttributes"] {
assert!(!s.is_enabled(id), "menu enablement of {id} still follows the selection");
}
}
#[test]
fn naming_nothing_usable_does_not_enable_a_command() {
let mut s = demo();
let before = s.project.clone();
// no ids, the wrong type, and a key the command does not take
for p in [json!({"clips": []}), json!({"clips": "all"}), json!({"items": [1]})] {
assert_eq!(disabled(s.execute("edit.rippleDelete", p.clone())), "nothing selected", "{p}");
}
// ids of no clip and values that are not ids: still disabled, and the reason names them (#591)
let why = disabled(s.execute("edit.rippleDelete", json!({"clips": [987_654_321u64]})));
assert!(why.starts_with("no clip 987654321 in the active sequence"), "{why}");
let why = disabled(s.execute("edit.rippleDelete", json!({"clips": [-1, 1.5, null]})));
assert!(why.starts_with("-1 is not a clip id"), "{why}");
assert_eq!(disabled(s.execute("clip.replaceFromBin", json!({"clips": [v1(&s)[0].id.0], "item": 987_654_321u64}))), "select a clip in the Project panel");
// `edit.cut` takes no `clips`: it works on the selection only
assert_eq!(disabled(s.execute("edit.cut", json!({"clips": [v1(&s)[0].id.0]}))), "no clips or captions selected");
assert!(std::sync::Arc::ptr_eq(&before, &s.project), "nothing was edited");
}
#[test]
fn link_and_speed_take_explicit_clips_without_a_selection() {
let mut s = demo();
let (v, au) = (v1(&s)[0].clone(), a1(&s)[0].clone());
for id in ["clip.link", "clip.speedDuration"] {
assert!(!s.is_enabled(id));
assert_eq!(disabled(s.execute(id, json!({}))), "no clips selected");
}
// Link toggles the named pair
let was = v.link.is_some() && v.link == au.link;
let r = s.execute("clip.link", json!({"clips": [v.id.0, au.id.0]})).unwrap();
assert_eq!(r["linked"], !was);
assert_eq!(clip(&s, v.id).unwrap().link.is_some(), !was);
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(clip(&s, v.id).unwrap().link, v.link);
s.execute("edit.redo", json!({})).unwrap();
assert_eq!(clip(&s, v.id).unwrap().link.is_some(), !was);
s.execute("edit.undo", json!({})).unwrap();
// Speed/Duration on the last clip of V1 (nothing after it to run into)
let last = v1(&s).last().unwrap().clone();
s.execute("clip.speedDuration", json!({"clips": [last.id.0], "speed": 200})).unwrap();
let fast = clip(&s, last.id).unwrap();
assert!(fast.duration < last.duration, "{:?} -> {:?}", last.duration, fast.duration);
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(clip(&s, last.id).unwrap().duration, last.duration);
s.execute("edit.redo", json!({})).unwrap();
assert_eq!(clip(&s, last.id).unwrap().duration, fast.duration);
assert!(s.state.selection.is_empty() && !s.is_enabled("clip.speedDuration"), "menu enablement still follows the selection");
}
/// #591: a caller that names clips which cannot stand in for the selection hears why, instead of
/// "no clips selected": a clip of another sequence, an id of something else, a string id.
#[test]
fn named_clips_that_are_not_usable_say_why() {
let mut s = demo();
let demo_seq = s.state.active_sequence.unwrap();
let demo_name = s.project.item(demo_seq).unwrap().name.clone();
let last = v1(&s).last().unwrap().clone();
// a track id and a project item id are not clip ids
let track = s.active_sequence().unwrap().video_tracks[0].id.0;
let why = disabled(s.execute("clip.speedDuration", json!({"clips": [track], "speed": 50})));
assert_eq!(why, format!("no clip {track} in the active sequence (clip ids are the `clip` numbers of the items in sequence.inspect)"));
let why = disabled(s.execute("clip.speedDuration", json!({"clips": [last.item.0], "speed": 50})));
assert!(why.starts_with(&format!("no clip {} in the active sequence", last.item.0)), "{why}");
// a string is not an id
let why = disabled(s.execute("clip.speedDuration", json!({"clips": [last.id.0.to_string()], "speed": 50})));
assert!(why.starts_with(&format!("\"{}\" is not a clip id", last.id.0)), "{why}");
// `clip`, where the command documents it
let why = disabled(s.execute("graphics.setText", json!({"clip": "x", "text": "x"})));
assert!(why.starts_with("\"x\" is not a clip id"), "{why}");
// a clip of a sequence that is not the active one
s.execute("file.newSequence", json!({"name": "Other"})).unwrap();
assert_ne!(s.state.active_sequence, Some(demo_seq));
let why = disabled(s.execute("clip.speedDuration", json!({"clips": [last.id.0], "speed": 200})));
assert_eq!(
why,
format!("clip {} is in sequence \"{demo_name}\", not the active one: open it first with sequence.open {{\"item\":{}}}", last.id.0, demo_seq.0)
);
// and doing what it says works
s.execute("sequence.open", json!({"item": demo_seq.0})).unwrap();
s.execute("clip.speedDuration", json!({"clips": [last.id.0], "speed": 200})).unwrap();
assert!(clip(&s, last.id).unwrap().duration < last.duration);
// naming nothing keeps the selection's reason, for menus and callers alike
s.state.selection.clear();
assert_eq!(disabled(s.execute("clip.speedDuration", json!({"speed": 50}))), "no clips selected");
assert_eq!(disabled(s.execute("clip.speedDuration", json!({"clips": [], "speed": 50}))), "no clips selected");
}
#[test]
fn naming_targets_lifts_only_the_selection_condition() {
// no sequence: named clips cannot stand in for one
let mut empty = Session::default();
assert_eq!(disabled(empty.execute("edit.clear", json!({"clips": [1]}))), "no sequence is open");
assert_eq!(disabled(empty.execute("clip.speedDuration", json!({"clips": [1], "speed": 50}))), "no sequence is open");
let mut s = demo();
let a = v1(&s)[0].clone();
// the wrong kind of target: a video clip is not a graphic
assert_eq!(disabled(s.execute("graphics.setText", json!({"clip": a.id.0, "text": "x"}))), "select a graphic clip");
// a locked track is still the edit's own business: named or selected, the clip stays
s.execute("timeline.setTrack", json!({"track": "V1", "locked": true})).unwrap();
let _ = s.execute("edit.clear", json!({"clips": [a.id.0]}));
assert!(clip(&s, a.id).is_some(), "a clip on a locked track is not removed");
}
/// `project.delete` with explicit ids needs no Project-panel selection, for bins as much as for
/// items: the selection can hold both, so a named bin stands in for it (#244).
#[test]
fn project_delete_takes_explicit_bins_and_items_without_a_selection() {
let mut s = demo();
let before = s.project.items.len();
let empty = s.execute("file.newBin", json!({"name": "Empty"})).unwrap()["bin"].as_u64().unwrap();
let outer = s.execute("file.newBin", json!({"name": "Old footage"})).unwrap()["bin"].as_u64().unwrap();
let ocean = item_named(&s, "Ocean_Sunset.mp4");
s.execute("project.moveToBin", json!({"items": [ocean.0], "bin": outer})).unwrap();
s.state.project_selection.clear();
assert!(!s.is_enabled("project.delete"));
assert_eq!(disabled(s.execute("project.delete", json!({}))), "select an item in the Project panel");
// an empty bin, by its id alone
let r = s.execute("project.delete", json!({"items": [empty]})).unwrap();
assert_eq!(r, json!({"items": 0, "bins": 1, "offline": 0}));
assert!(s.project.root.find_bin(filmcraft_project::BinId(empty)).is_none());
// a bin with a clip in it, and an item, each by id alone
let r = s.execute("project.delete", json!({"items": [outer]})).unwrap();
assert_eq!(r, json!({"items": 1, "bins": 1, "offline": 0}));
assert!(s.project.item(ocean).is_none());
let dunes = item_named(&s, "Desert_Dunes.mp4");
let r = s.execute("project.delete", json!({"items": [dunes.0]})).unwrap();
assert_eq!(r, json!({"items": 1, "bins": 0, "offline": 0}));
assert_eq!(s.project.items.len(), before - 2);
assert!(s.state.project_selection.is_empty(), "the selection is left as it was");
assert!(!s.is_enabled("project.delete"), "menu enablement still follows the selection");
// ids of nothing, or of the project's own top bin, do not stand in for a selection
let root = s.project.root.id.0;
assert_eq!(disabled(s.execute("project.delete", json!({"items": [root]}))), "select an item in the Project panel");
assert_eq!(disabled(s.execute("project.delete", json!({"items": [999_999]}))), "select an item in the Project panel");
s.execute("edit.undo", json!({})).unwrap();
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(s.project.items.len(), before);
}
#[test]
fn link_multiple_video_and_audio_pairs_creates_one_link_per_pair() {
let mut s = demo();
let v_clips = v1(&s);
let a_clips = a1(&s);
assert!(v_clips.len() >= 3 && a_clips.len() >= 3);
let (v0, v1, v2) = (v_clips[0].id, v_clips[1].id, v_clips[2].id);
let (a0, a1, a2) = (a_clips[0].id, a_clips[1].id, a_clips[2].id);
// First, unlink all three pairs
let r = s.execute("clip.link", json!({"clips": [v0.0, a0.0, v1.0, a1.0, v2.0, a2.0]})).unwrap();
assert_eq!(r["linked"], false);
for cid in [v0, a0, v1, a1, v2, a2] {
assert_eq!(clip(&s, cid).unwrap().link, None);
}
// Now, run clip.link on all six clips. In Premiere parity (#507),
// it should create 3 separate links (one per pair), not one big link for all six.
let r = s.execute("clip.link", json!({"clips": [v0.0, a0.0, v1.0, a1.0, v2.0, a2.0]})).unwrap();
assert_eq!(r["linked"], true);
let l0 = clip(&s, v0).unwrap().link;
let la0 = clip(&s, a0).unwrap().link;
let l1 = clip(&s, v1).unwrap().link;
let la1 = clip(&s, a1).unwrap().link;
let l2 = clip(&s, v2).unwrap().link;
let la2 = clip(&s, a2).unwrap().link;
assert!(l0.is_some() && l1.is_some() && l2.is_some());
assert_eq!(l0, la0, "v0 linked to a0");
assert_eq!(l1, la1, "v1 linked to a1");
assert_eq!(l2, la2, "v2 linked to a2");
assert_ne!(l0, l1, "different pairs must not share the same link id");
assert_ne!(l1, l2, "different pairs must not share the same link id");
assert_ne!(l0, l2, "different pairs must not share the same link id");
}
/// A video clip with no overlapping selected audio, and audio with no overlapping video, stay
/// unlinked: a one-member link would make the clip read as "linked" with no partner.
#[test]
fn link_leaves_clips_without_a_partner_unlinked() {
let mut s = demo();
let (v, a) = (v1(&s), a1(&s));
let (v0, v1, a0, a2) = (v[0].id, v[1].id, a[0].id, a[2].id);
s.execute("clip.link", json!({"clips": [v0.0, v1.0, a0.0, a2.0]})).unwrap();
s.execute("clip.link", json!({"clips": [v0.0, v1.0, a0.0, a2.0]})).unwrap();
assert!(clip(&s, v0).unwrap().link.is_some());
assert_eq!(clip(&s, v0).unwrap().link, clip(&s, a0).unwrap().link);
assert_eq!(clip(&s, v1).unwrap().link, None, "v1 has no overlapping audio in the selection");
assert_eq!(clip(&s, a2).unwrap().link, None, "a2 has no overlapping video in the selection");
}
/// #1103: Unlink with a selection that also holds an unlinked clip (a title, a music clip) unlinks
/// the linked ones, as the Timeline's context menu offers, instead of re-linking them.
#[test]
fn unlink_with_an_unlinked_clip_in_the_selection_still_unlinks() {
let mut s = demo();
let (v, a) = (v1(&s), a1(&s));
let (v0, a0, v1, a1) = (v[0].id, a[0].id, v[1].id, a[1].id);
assert!(clip(&s, v0).unwrap().link.is_some() && clip(&s, v1).unwrap().link.is_some(), "the demo's clips start linked");
// make one clip unlinked on its own: its partner goes with it (no one-member link stays)
s.execute("clip.link", json!({"clips": [a1.0]})).unwrap();
assert_eq!(clip(&s, a1).unwrap().link, None);
assert_eq!(clip(&s, v1).unwrap().link, None, "the partner left alone is unlinked too");
s.execute("clip.link", json!({"clips": [v0.0, a0.0]})).unwrap();
s.execute("clip.link", json!({"clips": [v0.0, a0.0]})).unwrap();
assert!(clip(&s, v0).unwrap().link.is_some(), "v0 and a0 linked again");
// v0 + a0 linked, v1 not: Unlink
let r = s.execute("clip.link", json!({"clips": [v0.0, a0.0, v1.0]})).unwrap();
assert_eq!(r["linked"], false);
for c in [v0, a0, v1] {
assert_eq!(clip(&s, c).unwrap().link, None, "{c:?}");
}
}
/// #3620: timeline.delete aliases clear / ripple delete and accepts explicit clips without selection.
#[test]
fn timeline_delete_alias_deletes_and_ripple_deletes_explicit_clips() {
let mut s = demo();
let (a, b) = (v1(&s)[0].clone(), v1(&s)[1].clone());
assert!(s.is_enabled("timeline.delete"), "timeline.delete is enabled whenever a sequence is open");
// Regular delete by clip id
s.execute("timeline.delete", json!({"clip": a.id.0})).unwrap();
assert!(clip(&s, a.id).is_none() && clip(&s, b.id).is_some());
s.execute("edit.undo", json!({})).unwrap();
assert!(clip(&s, a.id).is_some());
// Ripple delete by clips list
let a_and_its_audio: Vec<u64> = s
.active_sequence()
.unwrap()
.all_tracks()
.flat_map(|t| &t.items)
.filter(|i| i.id == a.id || (i.link.is_some() && i.link == a.link))
.map(|i| i.id.0)
.collect();
s.execute("timeline.setTrack", json!({"track": "A2", "syncLock": false})).unwrap();
s.execute("timeline.delete", json!({"clips": a_and_its_audio, "ripple": true})).unwrap();
assert!(clip(&s, a.id).is_none());
assert_eq!(clip(&s, b.id).unwrap().start, a.start, "the next clip closes the gap");
// Malformed explicit targets are rejected and do not mutate selection
s.state.selection = vec![b.id];
assert!(s.execute("timeline.delete", json!({"clip": null})).is_err());
assert!(s.execute("edit.clear", json!({"clip": "invalid"})).is_err());
assert!(s.execute("edit.rippleDelete", json!({"clips": null})).is_err());
assert_eq!(s.state.selection, vec![b.id]);
assert!(clip(&s, b.id).is_some());
}
/// Every explicit-target shape that is not a valid, non-empty list of clips of the active
/// sequence is a param error, for each command sharing the deletion handling, and never falls
/// back to deleting the selection.
#[test]
fn deletion_commands_reject_invalid_explicit_targets_without_touching_the_selection() {
let mut s = demo();
let (a, b) = (v1(&s)[0].clone(), v1(&s)[1].clone());
let unknown = 9_999_999u64;
let bad_params = [
json!({"clip": null}),
json!({"clips": null}),
json!({"clip": "x"}),
json!({"clip": -1}),
json!({"clips": 5}),
json!({"clips": []}),
json!({"clips": [null]}),
json!({"clips": ["x"]}),
json!({"clips": [a.id.0, null]}),
json!({"clips": [unknown]}),
json!({"clips": [a.id.0, unknown]}),
json!({"clip": unknown}),
json!({"clip": a.id.0, "clips": [a.id.0]}),
json!({"clip": null, "clips": [a.id.0]}),
];
let before = v1(&s).len();
for cmd in ["edit.clear", "edit.rippleDelete", "timeline.delete"] {
for p in &bad_params {
s.state.selection = vec![b.id];
match s.execute(cmd, p.clone()) {
Err(EngineError::BadParams { .. }) => {}
other => panic!("{cmd} {p}: expected BadParams, got {other:?}"),
}
assert_eq!(s.state.selection, vec![b.id], "{cmd} {p}: selection untouched");
assert_eq!(v1(&s).len(), before, "{cmd} {p}: nothing deleted");
assert!(clip(&s, a.id).is_some() && clip(&s, b.id).is_some(), "{cmd} {p}: clips intact");
}
}
// timeline.delete: `ripple` must be a boolean when given
s.state.selection = vec![b.id];
for ripple in [json!("yes"), json!(1)] {
match s.execute("timeline.delete", json!({"clip": a.id.0, "ripple": ripple})) {
Err(EngineError::BadParams { .. }) => {}
other => panic!("timeline.delete ripple {ripple}: expected BadParams, got {other:?}"),
}
}
assert!(clip(&s, a.id).is_some() && clip(&s, b.id).is_some());
// no selection: still an error, nothing deleted
s.state.selection.clear();
for cmd in ["edit.clear", "edit.rippleDelete", "timeline.delete"] {
assert!(s.execute(cmd, json!({"clip": null})).is_err());
assert!(s.execute(cmd, json!({"clips": []})).is_err());
assert!(s.execute(cmd, json!({"clips": [unknown]})).is_err());
}
assert_eq!(v1(&s).len(), before);
}
/// Only V1 stays sync-locked, so a ripple of a lone V1 clip (linked selection is off) moves nothing else.
fn unlock_all_but_v1(s: &mut Session) {
let seq = s.active_sequence().unwrap();
let (nv, na) = (seq.video_tracks.len(), seq.audio_tracks.len());
let names = (2..=nv).map(|n| format!("V{n}")).chain((1..=na).map(|n| format!("A{n}")));
for track in names.collect::<Vec<_>>() {
s.execute("timeline.setTrack", json!({"track": track, "syncLock": false})).unwrap();
}
}
/// With neither `clip` nor `clips`, deletion still acts on the selection.
#[test]
fn deletion_commands_fall_back_to_the_selection_only_when_no_target_is_named() {
for cmd in ["edit.clear", "edit.rippleDelete", "timeline.delete"] {
let mut s = demo();
unlock_all_but_v1(&mut s);
let b = v1(&s)[1].clone();
s.state.selection = vec![b.id];
s.execute(cmd, json!({})).unwrap();
assert!(clip(&s, b.id).is_none(), "{cmd} deletes the selected clip");
assert!(s.state.selection.is_empty(), "{cmd} clears the selection");
}
let mut s = demo();
unlock_all_but_v1(&mut s);
let b = v1(&s)[1].clone();
s.state.selection = vec![b.id];
s.execute("timeline.delete", json!({"ripple": true})).unwrap();
assert!(clip(&s, b.id).is_none(), "timeline.delete ripple falls back to the selection");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.