Skip to content

FilmCraft: An open-source, nonlinear video editor written by scratch in pure Rust

45.7 KB
Raw Blame
use super::*;
use filmcraft_project::{Label, Project, SequenceSettings, TrackKind};
use filmcraft_time::FrameRate;
use proptest::prelude::*;

const R: FrameRate = FrameRate::FPS_24;

fn f(n: i64) -> Tick {
    R.tick_of(n)
}

struct Fx {
    seq: Sequence,
    next: u64,
}

fn media(_: ItemId) -> Option<Tick> {
    Some(f(1000))
}

impl Fx {
    fn new() -> Self {
        let mut p = Project::new("t");
        let s = p.new_sequence("s", SequenceSettings { frame_rate: R, ..Default::default() }, 3, 2, None);
        let seq = p.sequence(s).unwrap().clone();
        Self { seq, next: 10_000 }
    }
    fn ctx<'a>(next: &'a mut u64) -> EditCtx<'a> {
        EditCtx { next_id: next, media_duration: &media, media_start: &|_| Tick::ZERO, min_duration: f(1) }
    }
    fn v(&self, i: usize) -> TrackId {
        self.seq.video_tracks[i].id
    }
    fn a(&self, i: usize) -> TrackId {
        self.seq.audio_tracks[i].id
    }
    fn item(&mut self, start: i64, dur: i64, src_in: i64) -> TrackItem {
        self.next += 1;
        TrackItem {
            id: ClipId(self.next),
            item: ItemId(1),
            name: format!("c{}", self.next),
            label: Label::Iris,
            start: f(start),
            duration: f(dur),
            source_in: f(src_in),
            speed: 1.0,
            reverse: false,
            enabled: true,
            link: None,
            group: None,
            effects: vec![],
            markers: vec![],
            gain_db: 0.0,
            frame_hold: None,
            scale_to_frame: false,
            essential: None,
            multicam: None,
            time_interpolation: Default::default(),
            hold_filters: false,
            field_options: None,
            source_channels: Vec::new(),
            audio_stream: 0,
            graphic: None,
        }
    }
    fn put(&mut self, track: TrackId, start: i64, dur: i64, src_in: i64) -> ClipId {
        let it = self.item(start, dur, src_in);
        let id = it.id;
        let mut n = self.next;
        overwrite(&mut self.seq, vec![(track, it)], &mut Self::ctx(&mut n)).unwrap();
        self.next = n;
        id
    }
    fn spans(&self, track: TrackId) -> Vec<(i64, i64)> {
        self.seq.track(track).unwrap().items.iter().map(|i| (R.frame_at(i.start), R.frame_at(i.duration))).collect()
    }
}

#[test]
fn move_rejects_repeated_clip_ids_without_mutation() {
    for insert_mode in [false, true] {
        let mut fx = Fx::new();
        let (v1, v2) = (fx.v(0), fx.v(1));
        let c = fx.put(v1, 0, 10, 0);
        let before = fx.seq.clone();
        let mut n = fx.next;
        let result = move_items(&mut fx.seq, &[(c, v1, f(20)), (c, v2, f(20))], insert_mode, &mut Fx::ctx(&mut n));
        assert!(result.is_err(), "moving one identity to two tracks must be rejected: {result:?}");
        assert_eq!(fx.seq, before);
        assert_eq!(n, fx.next, "a rejected move consumes no ids");
    }
}

#[test]
fn overwrite_splits_underlying() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    fx.put(v1, 0, 100, 0);
    fx.put(v1, 40, 20, 500);
    assert_eq!(fx.spans(v1), vec![(0, 40), (40, 20), (60, 40)]);
    let right = &fx.seq.track(v1).unwrap().items[2];
    assert_eq!(right.source_in, f(60), "right remainder keeps media continuity");
    fx.seq.check().unwrap();
}

#[test]
fn insert_ripples_sync_locked_tracks() {
    let mut fx = Fx::new();
    let (v1, v2, a1) = (fx.v(0), fx.v(1), fx.a(0));
    fx.put(v1, 0, 50, 0);
    fx.put(v2, 60, 10, 0);
    fx.put(a1, 0, 100, 0);
    fx.seq.track_mut(v2).unwrap().sync_lock = false;
    let it = fx.item(20, 10, 0);
    let mut n = fx.next;
    insert(&mut fx.seq, vec![(v1, it)], &mut Fx::ctx(&mut n)).unwrap();
    fx.next = n;
    assert_eq!(fx.spans(v1), vec![(0, 20), (20, 10), (30, 30)]);
    assert_eq!(fx.spans(a1), vec![(0, 20), (30, 80)], "sync-locked audio split and shifted");
    assert_eq!(fx.spans(v2), vec![(60, 10)], "not sync-locked: untouched");
}

#[test]
fn razor_keeps_content_continuous() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let c = fx.put(v1, 10, 100, 200);
    let before = fx.seq.find_item(c).unwrap().1.source_time_at(f(70));
    let mut n = fx.next;
    let new = razor(&mut fx.seq, &[], f(50), &mut Fx::ctx(&mut n));
    assert_eq!(new.len(), 1);
    let right = fx.seq.find_item(new[0]).unwrap().1;
    assert_eq!(right.source_time_at(f(70)), before);
    assert_eq!(fx.spans(v1), vec![(10, 40), (50, 60)]);
}

#[test]
fn extract_and_lift() {
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    fx.put(v1, 0, 100, 0);
    fx.put(a1, 0, 100, 0);
    let mut n = fx.next;
    lift(&mut fx.seq, &[v1], TimeRange::new(f(10), f(10)), &mut Fx::ctx(&mut n));
    assert_eq!(fx.spans(v1), vec![(0, 10), (20, 80)]);
    extract(&mut fx.seq, &[v1], TimeRange::new(f(30), f(10)), &mut Fx::ctx(&mut n));
    assert_eq!(fx.spans(v1), vec![(0, 10), (20, 10), (30, 60)]);
    assert_eq!(fx.spans(a1), vec![(0, 30), (30, 60)]);
}

#[test]
fn ripple_delete_and_conflict() {
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    let a = fx.put(v1, 0, 10, 0);
    fx.put(v1, 10, 10, 0);
    ripple_delete_items(&mut fx.seq, &[a]).unwrap();
    assert_eq!(fx.spans(v1), vec![(0, 10)]);
    // audio under the gap blocks the ripple
    let b = fx.put(v1, 20, 10, 0);
    fx.put(a1, 22, 3, 0);
    assert_eq!(ripple_delete_items(&mut fx.seq, &[b]), Err(EditError::SyncLockConflict("A1".into())), "names the track in the way");
    assert_eq!(fx.spans(v1), vec![(0, 10), (20, 10)], "unchanged on failure");
}

#[test]
fn ripple_delete_closes_the_time_free_on_every_track() {
    // four clips on V1 with their sounds on A1; the second sound starts 2 early and ends 2 late
    let build = || {
        let mut fx = Fx::new();
        let (v1, a1) = (fx.v(0), fx.a(0));
        let v: Vec<ClipId> = [(0, 10), (10, 10), (20, 10), (30, 10)].iter().map(|(s, d)| fx.put(v1, *s, *d, 0)).collect();
        let a: Vec<ClipId> = [(0, 8), (8, 14), (22, 8), (30, 10)].iter().map(|(s, d)| fx.put(a1, *s, *d, 0)).collect();
        (fx, v, a)
    };
    let span = |start, len| TimeRange::new(f(start), f(len));
    // one clip with a split edit on both sides: the picture's stretch closes, everything later stays in sync
    let (mut fx, v, a) = build();
    assert_eq!(ripple_delete_items(&mut fx.seq, &[v[1], a[1]]), Ok(vec![span(10, 10)]));
    assert_eq!(fx.spans(fx.v(0)), vec![(0, 10), (10, 10), (20, 10)]);
    assert_eq!(fx.spans(fx.a(0)), vec![(0, 8), (12, 8), (20, 10)]);
    fx.seq.check().unwrap();
    // two neighbours with a split edit between them close as one stretch
    let (mut fx, v, a) = build();
    assert_eq!(ripple_delete_items(&mut fx.seq, &[v[1], a[1], v[2], a[2]]), Ok(vec![span(10, 20)]));
    assert_eq!(fx.spans(fx.v(0)), vec![(0, 10), (10, 10)]);
    assert_eq!(fx.spans(fx.a(0)), vec![(0, 8), (10, 10)]);
    // clips apart in time each close their own gap
    let (mut fx, v, a) = build();
    assert_eq!(ripple_delete_items(&mut fx.seq, &[v[0], a[0], v[3], a[3]]), Ok(vec![span(0, 8), span(30, 10)]));
    fx.seq.check().unwrap();

    // straight cuts with the sounds on alternating tracks: V1 [0,10) [10,20) [20,30), A1 [0,10) [20,30), A2 [10,20)
    let mut fx = Fx::new();
    let (v1, a1, a2) = (fx.v(0), fx.a(0), fx.a(1));
    let v: Vec<ClipId> = [0, 10, 20].iter().map(|s| fx.put(v1, *s, 10, 0)).collect();
    let (s0, s1) = (fx.put(a1, 0, 10, 0), fx.put(a2, 10, 10, 0));
    fx.put(a1, 20, 10, 0);
    assert_eq!(ripple_delete_items(&mut fx.seq, &[v[0], s0, v[1], s1]), Ok(vec![span(0, 20)]));
    assert_eq!((fx.spans(v1), fx.spans(a1), fx.spans(a2)), (vec![(0, 10)], vec![(0, 10)], vec![]));

    // a sound shorter than its picture with nothing round it: the whole picture closes
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    let (p, s) = (fx.put(v1, 10, 10, 0), fx.put(a1, 12, 6, 0));
    fx.put(v1, 20, 10, 0);
    fx.put(a1, 20, 10, 0);
    assert_eq!(ripple_delete_items(&mut fx.seq, &[p, s]), Ok(vec![span(10, 10)]));
    // with the neighbours' sound right up against it, only the sound's stretch can close
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    fx.put(a1, 0, 12, 0);
    let (p, s) = (fx.put(v1, 10, 10, 0), fx.put(a1, 12, 6, 0));
    fx.put(v1, 20, 10, 0);
    fx.put(a1, 18, 12, 0);
    assert_eq!(ripple_delete_items(&mut fx.seq, &[p, s]), Ok(vec![span(12, 6)]));
    assert_eq!((fx.spans(v1), fx.spans(a1)), (vec![(14, 10)], vec![(0, 12), (12, 12)]));

    // a linked sound on a locked track stays, and does not shrink the gap that closes
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    let (p, s) = (fx.put(v1, 10, 10, 0), fx.put(a1, 12, 6, 0));
    fx.put(v1, 20, 10, 0);
    fx.seq.track_mut(a1).unwrap().locked = true;
    fx.seq.track_mut(a1).unwrap().sync_lock = false;
    assert_eq!(ripple_delete_items(&mut fx.seq, &[p, s]), Ok(vec![span(10, 10)]));
    assert_eq!((fx.spans(v1), fx.spans(a1)), (vec![(10, 10)], vec![(12, 6)]));

    // nothing can close: what stays on each track covers the other track's deleted time. Refused, unchanged.
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    let x = fx.put(v1, 10, 10, 0);
    fx.put(v1, 30, 10, 0);
    fx.put(a1, 10, 10, 0);
    let y = fx.put(a1, 30, 10, 0);
    let before = fx.seq.clone();
    assert!(matches!(ripple_delete_items(&mut fx.seq, &[x, y]), Err(EditError::Other(_))));
    assert_eq!(fx.seq, before);
}

#[test]
fn close_gap_works() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    fx.put(v1, 0, 10, 0);
    fx.put(v1, 25, 10, 0);
    close_gap(&mut fx.seq, v1, f(15)).unwrap();
    assert_eq!(fx.spans(v1), vec![(0, 10), (10, 10)]);
}

#[test]
fn reversed_trim_uses_the_handle_its_playback_direction_consumes() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    // source frames [5, 15) played backwards; the media is 1000 frames long
    let a = fx.put(v1, 30, 10, 5);
    fx.seq.find_item_mut(a).unwrap().1.reverse = true;
    let mut n = fx.next;
    // out extends into the 5 frames before source_in, not into the 985 after source_out
    let d = trim(&mut fx.seq, a, Edge::Out, TrimMode::Regular, f(20), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(d, f(5));
    let it = fx.seq.find_item(a).unwrap().1;
    assert_eq!((it.source_in, it.source_out()), (f(0), f(15)));
    // in extends into the media after source_out
    let d = trim(&mut fx.seq, a, Edge::In, TrimMode::Regular, -f(10), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(d, -f(10));
    let it = fx.seq.find_item(a).unwrap().1;
    assert_eq!((it.source_in, it.source_out()), (f(0), f(25)));
    fx.seq.check().unwrap();
}

#[test]
fn regular_trim_respects_neighbours_and_handles() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 0, 10, 5);
    fx.put(v1, 12, 10, 0);
    let mut n = fx.next;
    // out: only 2 frames of space before the neighbour
    let d = trim(&mut fx.seq, a, Edge::Out, TrimMode::Regular, f(5), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(d, f(2));
    // in: 5 frames of head handle, but item starts at 0 so no space to the left
    let d = trim(&mut fx.seq, a, Edge::In, TrimMode::Regular, -f(3), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(d, Tick::ZERO);
    let d = trim(&mut fx.seq, a, Edge::In, TrimMode::Regular, f(3), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(d, f(3));
    assert_eq!(fx.seq.find_item(a).unwrap().1.source_in, f(8));
    fx.seq.check().unwrap();
}

#[test]
fn trim_on_a_locked_track_is_refused() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 0, 100, 0);
    fx.seq.track_mut(v1).unwrap().locked = true;
    let mut n = fx.next;
    assert_eq!(trim(&mut fx.seq, a, Edge::Out, TrimMode::Regular, -f(20), &mut Fx::ctx(&mut n)), Err(EditError::Locked));
    assert_eq!(fx.spans(v1), vec![(0, 100)]);
}

#[test]
fn held_regular_in_trim_stops_at_previous_clip() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    fx.put(v1, 0, 10, 0);
    let b = fx.put(v1, 15, 10, 5);
    fx.seq.find_item_mut(b).unwrap().1.frame_hold = Some(f(5));
    let mut n = fx.next;
    // 5 frames of gap: a 20 frame extension is clamped to 5 instead of overlapping the previous clip
    let d = trim(&mut fx.seq, b, Edge::In, TrimMode::Regular, -f(20), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(d, -f(5));
    assert_eq!(fx.spans(v1), vec![(0, 10), (10, 15)]);
    // no space left: nothing to do, and no error
    let d = trim(&mut fx.seq, b, Edge::In, TrimMode::Regular, -f(3), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(d, Tick::ZERO);
    fx.seq.check().unwrap();
}

#[test]
fn ripple_trim_shifts_following() {
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    let a = fx.put(v1, 0, 10, 0);
    fx.put(v1, 10, 10, 0);
    fx.put(a1, 30, 5, 0);
    let mut n = fx.next;
    trim(&mut fx.seq, a, Edge::Out, TrimMode::Ripple, f(4), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(v1), vec![(0, 14), (14, 10)]);
    assert_eq!(fx.spans(a1), vec![(34, 5)]);
    trim(&mut fx.seq, a, Edge::In, TrimMode::Ripple, f(2), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(v1), vec![(0, 12), (12, 10)]);
}

#[test]
fn ripple_trim_group_takes_a_split_edit_along() {
    // V1: a [0,10) then b [10,20). b's linked sound leads it by 4 on sync-locked A1: [6,20).
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    let a = fx.put(v1, 0, 10, 0);
    let b = fx.put(v1, 10, 10, 0);
    let sound = fx.put(a1, 6, 14, 0);
    for c in [b, sound] {
        fx.seq.find_item_mut(c).unwrap().1.link = Some(7);
    }
    let mut n = fx.next;
    ripple_trim_group(&mut fx.seq, &[a], Edge::Out, f(3), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!((fx.spans(v1), fx.spans(a1)), (vec![(0, 13), (13, 10)], vec![(9, 14)]), "longer: the early sound follows its picture");
    ripple_trim_group(&mut fx.seq, &[a], Edge::Out, -f(5), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!((fx.spans(v1), fx.spans(a1)), (vec![(0, 8), (8, 10)], vec![(4, 14)]), "shorter: it follows too");
    // the sound would start before the sequence does: refused, nothing changes
    assert!(matches!(ripple_trim_group(&mut fx.seq, &[a], Edge::Out, -f(5), &mut Fx::ctx(&mut n)), Err(EditError::SyncLockConflict(_))));
    // another clip right before the sound leaves it no room either
    fx.put(a1, 0, 4, 0);
    assert!(matches!(ripple_trim_group(&mut fx.seq, &[a], Edge::Out, -f(2), &mut Fx::ctx(&mut n)), Err(EditError::SyncLockConflict(_))));
    assert_eq!((fx.spans(v1), fx.spans(a1)), (vec![(0, 8), (8, 10)], vec![(0, 4), (4, 14)]), "unchanged on failure");
    // a linked clip that ends before the cut is not a split edit and stays where it is
    let early = fx.put(fx.a(1), 0, 3, 0);
    fx.seq.find_item_mut(early).unwrap().1.link = Some(7);
    ripple_trim_group(&mut fx.seq, &[a], Edge::Out, f(2), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(fx.a(1)), vec![(0, 3)]);
    fx.seq.check().unwrap();

    // In edge: V1 b [10,20), c [20,30); c's sound starts 12 early on A1: [8,30). b loses 3 at its head.
    let mut fx = Fx::new();
    let (v1, v2, a1, a2) = (fx.v(0), fx.v(1), fx.a(0), fx.a(1));
    fx.put(v1, 0, 10, 0);
    let b = fx.put(v1, 10, 10, 0);
    let c = fx.put(v1, 20, 10, 0);
    let c_sound = fx.put(a1, 8, 22, 0);
    // two more clips linked to b that the caller did not put in the group
    let b_sound = fx.put(a2, 10, 10, 0);
    let b_top = fx.put(v2, 12, 8, 0);
    for (x, link) in [(c, 7), (c_sound, 7), (b, 8), (b_sound, 8), (b_top, 8)] {
        fx.seq.find_item_mut(x).unwrap().1.link = Some(link);
    }
    let mut n = fx.next;
    ripple_trim_group(&mut fx.seq, &[b], Edge::In, f(3), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!((fx.spans(v1), fx.spans(a1)), (vec![(0, 10), (10, 7), (17, 10)], vec![(5, 22)]), "c and its early sound move up together");
    assert_eq!((fx.spans(v2), fx.spans(a2)), (vec![(9, 8)], vec![(10, 10)]), "the trimmed clip's own partners never follow");

    // a crossfade into the early sound from a clip that stays behind no longer sits on a cut: it goes
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    let a = fx.put(v1, 0, 10, 0);
    let b = fx.put(v1, 10, 10, 0);
    let stays = fx.put(a1, 0, 6, 0);
    let sound = fx.put(a1, 6, 14, 0);
    for x in [b, sound] {
        fx.seq.find_item_mut(x).unwrap().1.link = Some(7);
    }
    fx.seq.track_mut(a1).unwrap().transitions = vec![Transition {
        id: TransitionId(1),
        effect: filmcraft_project::find_effect("cross_dissolve").unwrap().instance(),
        start: f(4),
        duration: f(4),
        from: Some(stays),
        to: Some(sound),
        align: Default::default(),
        reverse: false,
    }];
    let mut n = fx.next;
    ripple_trim_group(&mut fx.seq, &[a], Edge::Out, f(3), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(a1), vec![(0, 6), (9, 14)]);
    assert!(fx.seq.track(a1).unwrap().transitions.is_empty());
}

#[test]
fn roll_slip_slide() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 0, 10, 10);
    let b = fx.put(v1, 10, 10, 10);
    let c = fx.put(v1, 20, 10, 10);
    let mut n = fx.next;
    roll(&mut fx.seq, a, b, f(3), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(v1), vec![(0, 13), (13, 7), (20, 10)]);
    assert_eq!(fx.seq.find_item(b).unwrap().1.source_in, f(13));
    let d = slip(&mut fx.seq, c, -f(50), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(d, -f(10), "slip clamps at media start");
    slide(&mut fx.seq, b, f(2), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(v1), vec![(0, 15), (15, 7), (22, 8)]);
    fx.seq.check().unwrap();
}

#[test]
fn slide_keeps_reversed_neighbours_content() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 0, 30, 20);
    let b = fx.put(v1, 30, 30, 50);
    let c = fx.put(v1, 60, 30, 70);
    for id in [a, c] {
        fx.seq.find_item_mut(id).unwrap().1.reverse = true;
    }
    let mut n = fx.next;
    slide(&mut fx.seq, b, f(10), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(v1), vec![(0, 40), (40, 30), (70, 20)]);
    assert_eq!(fx.seq.find_item(a).unwrap().1.source_in, f(10));
    assert_eq!(fx.seq.find_item(b).unwrap().1.source_in, f(50));
    assert_eq!(fx.seq.find_item(c).unwrap().1.source_in, f(70));
    fx.seq.check().unwrap();
}

#[test]
fn transitions_stay_on_their_cuts() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 0, 10, 10);
    let b = fx.put(v1, 10, 10, 10);
    let c = fx.put(v1, 20, 10, 10);
    let cross = |id, start, from, to| Transition {
        id: TransitionId(id),
        effect: filmcraft_project::find_effect("cross_dissolve").unwrap().instance(),
        start: f(start),
        duration: f(4),
        from,
        to,
        align: Default::default(),
        reverse: false,
    };
    let t = fx.seq.track_mut(v1).unwrap();
    t.transitions = vec![cross(1, 8, Some(a), Some(b)), cross(2, 18, Some(b), Some(c)), cross(3, 26, Some(c), None)];
    // every transition is centred on its cut (or ends with the clip it fades out)
    let check = |fx: &Fx, what: &str| {
        let t = fx.seq.track(v1).unwrap();
        for tr in &t.transitions {
            let cut = match tr.to {
                Some(to) => t.item(to).unwrap().start,
                None => t.item(tr.from.unwrap()).unwrap().end() - f(2),
            };
            assert_eq!(tr.start + f(2), cut, "{what}: transition {:?} left its cut", tr.id);
        }
        assert_eq!(t.transitions.len(), 3, "{what}");
    };
    let mut n = fx.next;
    trim(&mut fx.seq, a, Edge::Out, TrimMode::Ripple, f(4), &mut Fx::ctx(&mut n)).unwrap();
    check(&fx, "ripple trim out");
    trim(&mut fx.seq, b, Edge::In, TrimMode::Ripple, f(3), &mut Fx::ctx(&mut n)).unwrap();
    check(&fx, "ripple trim in");
    ripple_trim_group(&mut fx.seq, &[b], Edge::Out, -f(2), &mut Fx::ctx(&mut n)).unwrap();
    check(&fx, "ripple trim group");
    roll(&mut fx.seq, b, c, f(2), &mut Fx::ctx(&mut n)).unwrap();
    check(&fx, "roll");
    slide(&mut fx.seq, b, -f(3), &mut Fx::ctx(&mut n)).unwrap();
    check(&fx, "slide");
    set_speed(&mut fx.seq, b, 0.5, false, true, &mut Fx::ctx(&mut n)).unwrap();
    check(&fx, "ripple speed change");
    fx.seq.check().unwrap();
}

#[test]
fn fades_follow_a_regular_trim() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 10, 20, 10);
    let fade = |id, start, from, to| Transition {
        id: TransitionId(id),
        effect: filmcraft_project::find_effect("cross_dissolve").unwrap().instance(),
        start: f(start),
        duration: f(6),
        from,
        to,
        align: Default::default(),
        reverse: false,
    };
    fx.seq.track_mut(v1).unwrap().transitions = vec![fade(1, 10, None, Some(a)), fade(2, 24, Some(a), None)];
    let spans = |fx: &Fx| fx.seq.track(v1).unwrap().transitions.iter().map(|t| (t.start, t.duration)).collect::<Vec<_>>();
    let mut n = fx.next;
    trim(&mut fx.seq, a, Edge::In, TrimMode::Regular, f(2), &mut Fx::ctx(&mut n)).unwrap();
    trim(&mut fx.seq, a, Edge::Out, TrimMode::Regular, f(4), &mut Fx::ctx(&mut n)).unwrap();
    // the fade in starts with the clip (12), the fade out ends with it (34)
    assert_eq!(spans(&fx), vec![(f(12), f(6)), (f(28), f(6))]);
    // a clip trimmed shorter than its fades keeps them inside it
    trim(&mut fx.seq, a, Edge::Out, TrimMode::Regular, -f(18), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(spans(&fx), vec![(f(12), f(4)), (f(12), f(4))]);
    fx.seq.check().unwrap();
}

#[test]
fn fades_follow_a_non_ripple_speed_change() {
    // #918: faster without ripple shortens the clip; the fade-out stays on the new out point.
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 0, 100, 0);
    fx.seq.track_mut(v1).unwrap().transitions = vec![Transition {
        id: TransitionId(1),
        effect: filmcraft_project::find_effect("cross_dissolve").unwrap().instance(),
        start: f(90),
        duration: f(10),
        from: Some(a),
        to: None,
        align: Default::default(),
        reverse: false,
    }];
    let mut n = fx.next;
    set_speed(&mut fx.seq, a, 2.0, false, false, &mut Fx::ctx(&mut n)).unwrap();
    let tr = &fx.seq.track(v1).unwrap().transitions[0];
    assert_eq!(fx.spans(v1), vec![(0, 50)]);
    assert_eq!((tr.start, tr.duration), (f(40), f(10)));
    fx.seq.check().unwrap();
}

/// A regular trim or a non-ripple speed change that shortens one of the two clips of a transition
/// keeps the transition within them, and its stored alignment follows where it now sits on the cut.
#[test]
fn a_transition_stays_within_its_clips_after_a_regular_trim_or_speed_change() {
    for (case, expected) in [("Out trim of the second clip", 7), ("In trim of the first clip", 9), ("speed change of the second clip", 7)] {
        let mut fx = Fx::new();
        let v1 = fx.v(0);
        let a = fx.put(v1, 0, 10, 10);
        let b = fx.put(v1, 10, 10, 10);
        fx.seq.track_mut(v1).unwrap().transitions = vec![Transition {
            id: TransitionId(1),
            effect: filmcraft_project::find_effect("cross_dissolve").unwrap().instance(),
            start: f(8),
            duration: f(4),
            from: Some(a),
            to: Some(b),
            align: filmcraft_project::TransitionAlign::EndAtCut,
            reverse: false,
        }];
        let mut n = fx.next;
        match case {
            "Out trim of the second clip" => {
                trim(&mut fx.seq, b, Edge::Out, TrimMode::Regular, -f(9), &mut Fx::ctx(&mut n)).unwrap();
            }
            "In trim of the first clip" => {
                trim(&mut fx.seq, a, Edge::In, TrimMode::Regular, f(9), &mut Fx::ctx(&mut n)).unwrap();
            }
            _ => set_speed(&mut fx.seq, b, 10.0, false, false, &mut Fx::ctx(&mut n)).unwrap(),
        }
        let tr = &fx.seq.track(v1).unwrap().transitions[0];
        assert_eq!((tr.start, tr.duration), (f(expected), f(4)), "{case}");
        assert_eq!(tr.align, filmcraft_project::TransitionAlign::CenterAtCut, "{case}");
        fx.seq.check().unwrap();
    }
}

/// A regular trim that leaves the two clips of a transition shorter than it, together, shortens
/// the transition to the clips.
#[test]
fn a_regular_trim_shortens_a_transition_longer_than_its_clips() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 0, 2, 10);
    let b = fx.put(v1, 2, 10, 10);
    fx.seq.track_mut(v1).unwrap().transitions = vec![Transition {
        id: TransitionId(1),
        effect: filmcraft_project::find_effect("cross_dissolve").unwrap().instance(),
        start: f(0),
        duration: f(4),
        from: Some(a),
        to: Some(b),
        align: filmcraft_project::TransitionAlign::StartAtCut,
        reverse: false,
    }];
    let mut n = fx.next;
    trim(&mut fx.seq, b, Edge::Out, TrimMode::Regular, -f(9), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(v1), vec![(0, 2), (2, 1)]);
    let tr = &fx.seq.track(v1).unwrap().transitions[0];
    assert_eq!((tr.start, tr.duration), (f(0), f(3)), "the transition covers both clips and no more");
    assert_eq!(tr.align, filmcraft_project::TransitionAlign::CenterAtCut);
    fx.seq.check().unwrap();
}

#[test]
fn transitions_travel_with_moved_clips() {
    // V1: a [0,10) fading in, b [10,20), c [20,30); b→c crossfade, c fading out
    let mut fx = Fx::new();
    let (v1, v2) = (fx.v(0), fx.v(1));
    let a = fx.put(v1, 0, 10, 10);
    let b = fx.put(v1, 10, 10, 10);
    let c = fx.put(v1, 20, 10, 10);
    let tr = |id, start, from, to| Transition {
        id: TransitionId(id),
        effect: filmcraft_project::find_effect("cross_dissolve").unwrap().instance(),
        start: f(start),
        duration: f(4),
        from,
        to,
        align: Default::default(),
        reverse: false,
    };
    fx.seq.track_mut(v1).unwrap().transitions = vec![tr(1, 0, None, Some(a)), tr(2, 18, Some(b), Some(c)), tr(3, 26, Some(c), None)];
    let at = |fx: &Fx, track: TrackId| -> Vec<(u64, i64)> { fx.seq.track(track).unwrap().transitions.iter().map(|t| (t.id.0, R.frame_at(t.start))).collect() };
    let mut n = fx.next;
    // a fade at a clip's edge goes with it, to another track too
    move_items(&mut fx.seq, &[(a, v2, f(40))], false, &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!((at(&fx, v1), at(&fx, v2)), (vec![(2, 18), (3, 26)], vec![(1, 40)]));
    // a cut whose two clips move together keeps its transition, in an insert move as well
    move_items(&mut fx.seq, &[(b, v1, f(60)), (c, v1, f(70))], true, &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(at(&fx, v1), vec![(2, 68), (3, 76)]);
    // a crossfade whose partner stays behind is dropped; the moving clip's own fade stays with it
    move_items(&mut fx.seq, &[(c, v1, f(90))], false, &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(at(&fx, v1), vec![(3, 96)]);
    fx.seq.check().unwrap();
}

#[test]
fn rate_stretch_and_speed() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 0, 10, 0);
    let mut n = fx.next;
    let s = rate_stretch(&mut fx.seq, a, Edge::Out, f(10), &mut Fx::ctx(&mut n)).unwrap();
    assert!((s - 0.5).abs() < 1e-9);
    set_speed(&mut fx.seq, a, 2.0, false, true, &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(v1), vec![(0, 5)]);
}

#[test]
fn linked_rate_stretch_uses_the_tighter_neighbour() {
    // picture and sound are 60 frames; a later clip on A1 starts at 70, so the sound has only 10
    // frames of room. Stretching the pair +20 must not leave the picture at 80f / 0.75x and the
    // sound at 70f / 6/7x while still linked.
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    let pic = fx.put(v1, 0, 60, 0);
    let snd = fx.put(a1, 0, 60, 0);
    fx.put(a1, 70, 10, 0);
    for c in [pic, snd] {
        fx.seq.find_item_mut(c).unwrap().1.link = Some(1);
    }
    let mut n = fx.next;
    let speed = rate_stretch_items(&mut fx.seq, &[pic, snd], Edge::Out, f(20), &mut Fx::ctx(&mut n)).unwrap();
    assert!((speed - 60.0 / 70.0).abs() < 1e-9);
    let (p, s) = (fx.seq.find_item(pic).unwrap().1, fx.seq.find_item(snd).unwrap().1);
    assert_eq!((R.frame_at(p.duration), R.frame_at(s.duration)), (70, 70));
    assert!((p.speed - s.speed).abs() < 1e-12);
    assert_eq!(fx.spans(a1), vec![(0, 70), (70, 10)]);
    fx.seq.check().unwrap();
}

#[test]
fn speed_on_a_linked_group_ripples_once() {
    // V1: a [0,10), b [10,20). A1: a's sound [0,10), b's sound [10,20).
    let build = |sound_len: i64| {
        let mut fx = Fx::new();
        let (v1, a1) = (fx.v(0), fx.a(0));
        let a = fx.put(v1, 0, 10, 0);
        fx.put(v1, 10, 10, 0);
        let sound = fx.put(a1, 0, sound_len, 0);
        fx.put(a1, sound_len, 10, 0);
        (fx, a, sound)
    };
    for (speed, picture, later) in [(0.5, (0, 20), (20, 10)), (2.0, (0, 5), (5, 10))] {
        let (mut fx, a, sound) = build(10);
        let mut n = fx.next;
        set_speed_group(&mut fx.seq, &[a, sound], speed, false, true, &mut Fx::ctx(&mut n)).unwrap();
        assert_eq!((fx.spans(fx.v(0)), fx.spans(fx.a(0))), (vec![picture, later], vec![picture, later]), "{speed}");
    }
    // a split edit: the sound is 4 longer. Later clips move by the larger change, on both tracks.
    let (mut fx, a, sound) = build(14);
    let mut n = fx.next;
    set_speed_group(&mut fx.seq, &[a, sound], 0.5, false, true, &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!((fx.spans(fx.v(0)), fx.spans(fx.a(0))), (vec![(0, 20), (24, 10)], vec![(0, 28), (28, 10)]));
    let (mut fx, a, sound) = build(14);
    let mut n = fx.next;
    set_speed_group(&mut fx.seq, &[a, sound], 2.0, false, true, &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!((fx.spans(fx.v(0)), fx.spans(fx.a(0))), (vec![(0, 5), (5, 10)], vec![(0, 7), (9, 10)]));
    fx.seq.check().unwrap();
    // two clips of one track are not one group; a missing clip changes nothing
    let (mut fx, a, _) = build(10);
    let b = fx.seq.video_tracks[0].items[1].id;
    let before = fx.seq.clone();
    let mut n = fx.next;
    assert!(set_speed_group(&mut fx.seq, &[a, b], 2.0, false, true, &mut Fx::ctx(&mut n)).is_err());
    assert!(set_speed_group(&mut fx.seq, &[a, ClipId(1)], 2.0, false, true, &mut Fx::ctx(&mut n)).is_err());
    assert_eq!(fx.seq, before);
}

#[test]
fn move_with_insert_and_overwrite() {
    let mut fx = Fx::new();
    let (v1, v2) = (fx.v(0), fx.v(1));
    let a = fx.put(v1, 0, 10, 0);
    fx.put(v2, 0, 30, 0);
    let mut n = fx.next;
    move_items(&mut fx.seq, &[(a, v2, f(5))], false, &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(v1), vec![]);
    assert_eq!(fx.spans(v2), vec![(0, 5), (5, 10), (15, 15)]);
}

#[derive(Debug, Clone)]
enum Op {
    Over(usize, i64, i64),
    Ins(usize, i64, i64),
    Razor(i64),
    Extract(i64, i64),
    TrimOut(usize, i64),
    Ripple(usize),
}

fn op() -> impl Strategy<Value = Op> {
    prop_oneof![
        (0usize..3, 0i64..200, 1i64..50).prop_map(|(t, s, d)| Op::Over(t, s, d)),
        (0usize..3, 0i64..200, 1i64..50).prop_map(|(t, s, d)| Op::Ins(t, s, d)),
        (0i64..250).prop_map(Op::Razor),
        (0i64..200, 1i64..30).prop_map(|(s, d)| Op::Extract(s, d)),
        (0usize..20, -20i64..20).prop_map(|(i, d)| Op::TrimOut(i, d)),
        (0usize..20).prop_map(Op::Ripple),
    ]
}

proptest! {
    #[test]
    fn never_overlaps(ops in proptest::collection::vec(op(), 1..40)) {
        let mut fx = Fx::new();
        let tracks = [fx.v(0), fx.v(1), fx.a(0)];
        for o in ops {
            let mut n = fx.next;
            match o {
                Op::Over(t, s, d) => { let it = fx.item(s, d, 0); n = fx.next; let _ = overwrite(&mut fx.seq, vec![(tracks[t], it)], &mut Fx::ctx(&mut n)); }
                Op::Ins(t, s, d) => { let it = fx.item(s, d, 0); n = fx.next; let _ = insert(&mut fx.seq, vec![(tracks[t], it)], &mut Fx::ctx(&mut n)); }
                Op::Razor(t) => { razor(&mut fx.seq, &[], f(t), &mut Fx::ctx(&mut n)); }
                Op::Extract(s, d) => { extract(&mut fx.seq, &[tracks[0]], TimeRange::new(f(s), f(d)), &mut Fx::ctx(&mut n)); }
                Op::TrimOut(i, d) => {
                    let ids: Vec<ClipId> = fx.seq.all_tracks().flat_map(|t| t.items.iter().map(|x| x.id)).collect();
                    if let Some(c) = ids.get(i) { let _ = trim(&mut fx.seq, *c, Edge::Out, TrimMode::Regular, f(d), &mut Fx::ctx(&mut n)); }
                }
                Op::Ripple(i) => {
                    let ids: Vec<ClipId> = fx.seq.all_tracks().flat_map(|t| t.items.iter().map(|x| x.id)).collect();
                    if let Some(c) = ids.get(i) { let _ = ripple_delete_items(&mut fx.seq, &[*c]); }
                }
            }
            fx.next = fx.next.max(n);
            prop_assert!(fx.seq.check().is_ok(), "{:?}", fx.seq.check());
            for t in fx.seq.all_tracks() { for i in &t.items { prop_assert!(i.start >= Tick::ZERO); } }
        }
    }

    #[test]
    fn insert_then_extract_is_identity(s in 0i64..100, d in 1i64..40) {
        let mut fx = Fx::new();
        let (v1, a1) = (fx.v(0), fx.a(0));
        fx.put(v1, 0, 60, 0);
        fx.put(v1, 70, 30, 100);
        fx.put(a1, 10, 80, 0);
        let before: Vec<Vec<(i64, i64)>> = [v1, a1].iter().map(|t| fx.spans(*t)).collect();
        let it = fx.item(s, d, 0);
        let mut n = fx.next;
        insert(&mut fx.seq, vec![(v1, it)], &mut Fx::ctx(&mut n)).unwrap();
        extract(&mut fx.seq, &[v1], TimeRange::new(f(s), f(d)), &mut Fx::ctx(&mut n));
        // content ranges are identical after merging split pieces
        for (k, t) in [v1, a1].iter().enumerate() {
            let merged = merge(fx.spans(*t));
            prop_assert_eq!(merged, merge(before[k].clone()));
        }
    }
}

fn merge(v: Vec<(i64, i64)>) -> Vec<(i64, i64)> {
    let mut out: Vec<(i64, i64)> = Vec::new();
    for (s, d) in v {
        if let Some(last) = out.last_mut()
            && last.0 + last.1 == s
        {
            last.1 += d;
            continue;
        }
        out.push((s, d));
    }
    out
}

#[test]
fn unused_kind_import() {
    let _ = TrackKind::Video;
}

#[test]
fn hostile_speeds_are_refused_or_clamped_never_overflow() {
    // a tiny speed used to saturate the new duration to i64::MAX, then the ripple shift overflowed
    for speed in [1e-7, 1e-300, f64::MIN_POSITIVE, f64::NAN, f64::INFINITY, -1.0, 0.0] {
        let mut fx = Fx::new();
        let v1 = fx.v(0);
        let a = fx.put(v1, 0, 10, 10);
        let _b = fx.put(v1, 10, 10, 10);
        let before = fx.seq.clone();
        let mut n = fx.next;
        let r = set_speed_group(&mut fx.seq, &[a], speed, false, true, &mut Fx::ctx(&mut n));
        match r {
            Ok(()) => fx.seq.check().unwrap(),
            Err(_) => assert_eq!(format!("{:?}", fx.seq), format!("{before:?}"), "{speed}: a refused edit changes nothing"),
        }
    }
}

#[test]
fn shorter_head_into_an_l_cut_keeps_the_earlier_sound_where_it_is() {
    // V1: a [0,10), b [10,20), c [20,30). a's sound on sync-locked A1 runs 3 into b: [0,13) (an L
    // cut). b loses 3 at its head: a never moves, so its sound stays and the L cut still ends at 13.
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    let a = fx.put(v1, 0, 10, 0);
    let b = fx.put(v1, 10, 10, 0);
    fx.put(v1, 20, 10, 0);
    let a_sound = fx.put(a1, 0, 13, 0);
    for x in [a, a_sound] {
        fx.seq.find_item_mut(x).unwrap().1.link = Some(7);
    }
    let mut n = fx.next;
    ripple_trim_group(&mut fx.seq, &[b], Edge::In, f(3), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!((fx.spans(v1), fx.spans(a1)), (vec![(0, 10), (10, 7), (17, 10)], vec![(0, 13)]));
    fx.seq.check().unwrap();

    // later material on A1 moves up with the pictures; landing on the L cut's sound refuses
    let later = fx.put(a1, 15, 5, 0);
    assert!(matches!(ripple_trim_group(&mut fx.seq, &[b], Edge::In, f(3), &mut Fx::ctx(&mut n)), Err(EditError::SyncLockConflict(_))));
    assert_eq!(fx.spans(a1), vec![(0, 13), (15, 5)], "unchanged on failure");
    fx.seq.find_item_mut(later).unwrap().1.start = f(20);
    ripple_trim_group(&mut fx.seq, &[b], Edge::In, f(2), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!((fx.spans(v1), fx.spans(a1)), (vec![(0, 10), (10, 5), (15, 10)], vec![(0, 13), (18, 5)]));

    // unlinked material across the cut (a music bed) still refuses
    let mut fx = Fx::new();
    let (v1, a1) = (fx.v(0), fx.a(0));
    fx.put(v1, 0, 10, 0);
    let b = fx.put(v1, 10, 10, 0);
    fx.put(a1, 0, 13, 0);
    let mut n = fx.next;
    assert!(matches!(ripple_trim_group(&mut fx.seq, &[b], Edge::In, f(3), &mut Fx::ctx(&mut n)), Err(EditError::SyncLockConflict(_))));
    // so does a link with no partner left
    fx.seq.track_mut(a1).unwrap().items[0].link = Some(9);
    assert!(matches!(ripple_trim_group(&mut fx.seq, &[b], Edge::In, f(3), &mut Fx::ctx(&mut n)), Err(EditError::SyncLockConflict(_))));

    // a linked cutaway across the cut whose own partner reaches past it too is no L cut: it refuses
    let mut fx = Fx::new();
    let (v1, v2, a1) = (fx.v(0), fx.v(1), fx.a(0));
    fx.put(v1, 0, 10, 0);
    let b = fx.put(v1, 10, 10, 0);
    fx.put(v1, 20, 10, 0);
    let x = fx.put(v2, 5, 20, 0);
    let xs = fx.put(a1, 5, 20, 0);
    for c in [x, xs] {
        fx.seq.find_item_mut(c).unwrap().1.link = Some(7);
    }
    let mut n = fx.next;
    assert!(matches!(ripple_trim_group(&mut fx.seq, &[b], Edge::In, f(3), &mut Fx::ctx(&mut n)), Err(EditError::SyncLockConflict(_))));
}

#[test]
fn shorter_head_closes_the_stretch_after_the_cut_on_sync_locked_tracks() {
    // V1: a [0,10), b [10,20). a's sound on sync-locked A1 runs up to the cut: [0,10). b loses 3 at
    // its head; the stretch that closes is [10,13), where A1 is empty, so nothing refuses.
    for group in [false, true] {
        let mut fx = Fx::new();
        let (v1, a1) = (fx.v(0), fx.a(0));
        fx.put(v1, 0, 10, 0);
        let b = fx.put(v1, 10, 10, 0);
        fx.put(v1, 20, 10, 0);
        fx.put(a1, 0, 10, 0);
        let later = fx.put(a1, 20, 5, 0);
        let mut n = fx.next;
        if group {
            ripple_trim_group(&mut fx.seq, &[b], Edge::In, f(3), &mut Fx::ctx(&mut n)).unwrap();
        } else {
            trim(&mut fx.seq, b, Edge::In, TrimMode::Ripple, f(3), &mut Fx::ctx(&mut n)).unwrap();
        }
        assert_eq!((fx.spans(v1), fx.spans(a1)), (vec![(0, 10), (10, 7), (17, 10)], vec![(0, 10), (17, 5)]), "group {group}");
        // material inside the stretch that closes still refuses
        fx.seq.find_item_mut(later).unwrap().1.start = f(11);
        let r = if group {
            ripple_trim_group(&mut fx.seq, &[b], Edge::In, f(2), &mut Fx::ctx(&mut n))
        } else {
            trim(&mut fx.seq, b, Edge::In, TrimMode::Ripple, f(2), &mut Fx::ctx(&mut n))
        };
        assert!(matches!(r, Err(EditError::SyncLockConflict(_))), "group {group}");
    }
    // a clip on a sync-locked track that starts at the cut stays put while the pictures after it move
    // up: only the stretch after the cut sees it (the old stretch, before the cut, let it through)
    for group in [false, true] {
        let mut fx = Fx::new();
        let (v1, a1) = (fx.v(0), fx.a(0));
        fx.put(v1, 0, 10, 0);
        let b = fx.put(v1, 10, 10, 0);
        fx.put(v1, 20, 10, 0);
        fx.put(a1, 10, 5, 0);
        let mut n = fx.next;
        let r = if group {
            ripple_trim_group(&mut fx.seq, &[b], Edge::In, f(3), &mut Fx::ctx(&mut n))
        } else {
            trim(&mut fx.seq, b, Edge::In, TrimMode::Ripple, f(3), &mut Fx::ctx(&mut n))
        };
        assert!(matches!(r, Err(EditError::SyncLockConflict(_))), "group {group}");
        assert_eq!(fx.spans(v1), vec![(0, 10), (10, 10), (20, 10)], "unchanged on failure");
    }
}

#[test]
fn roll_reversed_clips_keeps_media_mapping() {
    let mut fx = Fx::new();
    let v = fx.v(0);
    let mut a = fx.item(0, 30, 20);
    a.reverse = true;
    let mut b = fx.item(30, 30, 50);
    b.reverse = true;
    let (ia, ib) = (a.id, b.id);
    fx.seq.track_mut(v).unwrap().items.extend([a, b]);
    let mut n = 0;
    roll(&mut fx.seq, ia, ib, f(10), &mut Fx::ctx(&mut n)).unwrap();
    let (_, l) = fx.seq.find_item(ia).unwrap();
    assert_eq!((l.start, l.duration, l.source_in), (f(0), f(40), f(10)));
    let (_, r) = fx.seq.find_item(ib).unwrap();
    assert_eq!((r.start, r.duration, r.source_in), (f(40), f(20), f(50)));
}

/// A rolling edit moves the transition on its cut with the cut, and stops where the transition
/// would leave one of its two clips.
#[test]
fn roll_keeps_the_transition_on_its_clips() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 0, 10, 10);
    let b = fx.put(v1, 10, 10, 10);
    fx.seq.track_mut(v1).unwrap().transitions = vec![Transition {
        id: TransitionId(1),
        effect: filmcraft_project::find_effect("cross_dissolve").unwrap().instance(),
        start: f(8),
        duration: f(4),
        from: Some(a),
        to: Some(b),
        align: Default::default(),
        reverse: false,
    }];
    let mut n = fx.next;
    // left: the transition reaches the sequence start after 8 frames, not the 9 the clips allow
    assert_eq!(roll(&mut fx.seq, a, b, -f(9), &mut Fx::ctx(&mut n)).unwrap(), -f(8));
    assert_eq!(fx.spans(v1), vec![(0, 2), (2, 18)]);
    let tr = &fx.seq.track(v1).unwrap().transitions[0];
    assert_eq!((tr.start, tr.duration), (f(0), f(4)), "the transition moved with the cut");
    // right: it reaches the end of the second clip after 16 frames, not 17
    assert_eq!(roll(&mut fx.seq, a, b, f(17), &mut Fx::ctx(&mut n)).unwrap(), f(16));
    assert_eq!(fx.spans(v1), vec![(0, 18), (18, 2)]);
    let tr = &fx.seq.track(v1).unwrap().transitions[0];
    assert_eq!((tr.start, tr.duration), (f(16), f(4)));
    fx.seq.check().unwrap();
}

/// A ripple trim or a slide that moves a cut close to the start of its first clip keeps the
/// transition on that cut within its two clips, and its stored alignment follows: an End at Cut
/// transition that now crosses the cut is stored as centered (Custom Start has no variant).
#[test]
fn edits_that_move_a_cut_keep_its_transition_on_its_clips() {
    for slide_it in [false, true] {
        let mut fx = Fx::new();
        let v1 = fx.v(0);
        let a = fx.put(v1, 0, 10, 10);
        let b = fx.put(v1, 10, 10, 10);
        fx.put(v1, 20, 10, 10);
        fx.seq.track_mut(v1).unwrap().transitions = vec![Transition {
            id: TransitionId(1),
            effect: filmcraft_project::find_effect("cross_dissolve").unwrap().instance(),
            start: f(6),
            duration: f(4),
            from: Some(a),
            to: Some(b),
            align: TransitionAlign::EndAtCut,
            reverse: false,
        }];
        let mut n = fx.next;
        if slide_it {
            slide(&mut fx.seq, b, -f(9), &mut Fx::ctx(&mut n)).unwrap();
        } else {
            trim(&mut fx.seq, a, Edge::Out, TrimMode::Ripple, -f(9), &mut Fx::ctx(&mut n)).unwrap();
        }
        let t = fx.seq.track(v1).unwrap();
        let (cut, a_start) = (t.item(b).unwrap().start, t.item(a).unwrap().start);
        assert_eq!(cut, f(1), "slide {slide_it}");
        let tr = &t.transitions[0];
        assert_eq!((tr.start, tr.duration), (a_start, f(4)), "slide {slide_it}: the transition starts with its first clip");
        assert_eq!(tr.align, TransitionAlign::CenterAtCut, "slide {slide_it}");
        fx.seq.check().unwrap();
    }
}

/// A ripple trim that shortens the second clip from its end leaves the cut where it is, and the
/// transition on that cut still stays within its two clips.
#[test]
fn a_ripple_trim_of_the_second_clips_end_keeps_the_transition_within_it() {
    let mut fx = Fx::new();
    let v1 = fx.v(0);
    let a = fx.put(v1, 0, 10, 10);
    let b = fx.put(v1, 10, 10, 10);
    fx.seq.track_mut(v1).unwrap().transitions = vec![Transition {
        id: TransitionId(1),
        effect: filmcraft_project::find_effect("cross_dissolve").unwrap().instance(),
        start: f(8),
        duration: f(4),
        from: Some(a),
        to: Some(b),
        align: TransitionAlign::CenterAtCut,
        reverse: false,
    }];
    let mut n = fx.next;
    trim(&mut fx.seq, b, Edge::Out, TrimMode::Ripple, -f(9), &mut Fx::ctx(&mut n)).unwrap();
    assert_eq!(fx.spans(v1), vec![(0, 10), (10, 1)]);
    let tr = &fx.seq.track(v1).unwrap().transitions[0];
    assert_eq!((tr.start, tr.duration), (f(7), f(4)), "the transition ends with the second clip");
    assert_eq!(tr.align, TransitionAlign::CenterAtCut);
    fx.seq.check().unwrap();
}

/// #374: moving an edge must not change which media sits under any timeline time the clip still
/// covers (the timeline's live trim preview draws its waveform from this item), and must leave the
/// item as the trim itself does.
#[test]
fn moving_an_edge_keeps_the_media_under_the_timeline() {
    let fx = Fx::new();
    let v1 = fx.v(0);
    for (speed, reverse, hold) in [(1.0, false, None), (2.0, false, None), (0.5, false, None), (1.0, true, None), (2.0, true, None), (1.0, false, Some(f(50)))]
    {
        for (edge, d) in [(Edge::In, f(7)), (Edge::In, -f(4)), (Edge::Out, -f(9)), (Edge::Out, f(3))] {
            let mut fresh = Fx::new();
            let c = fresh.put(v1, 100, 40, 200);
            {
                let it = fresh.seq.find_item_mut(c).unwrap().1;
                (it.speed, it.reverse, it.frame_hold) = (speed, reverse, hold);
            }
            let before = fresh.seq.find_item(c).unwrap().1.clone();
            let mut moved = before.clone();
            move_edge(&mut moved, edge, d, true);
            let label = format!("speed {speed} reverse {reverse} hold {hold:?} {edge:?} {d:?}");
            // every frame still covered shows the same media as before the move
            let mut t = moved.start.max(before.start);
            while t < moved.end().min(before.end()) {
                let (a, b) = (before.source_time_at(t), moved.source_time_at(t));
                assert!((a - b).0.abs() <= 1, "{label}: at {t:?} {a:?} became {b:?}");
                t += f(1);
            }
            // and the item is what the real (unclamped) trim makes of it
            let mut n = fresh.next;
            let got = trim(&mut fresh.seq, c, edge, TrimMode::Regular, d, &mut Fx::ctx(&mut n)).unwrap();
            assert_eq!(got, d, "{label}: not clamped");
            let trimmed = fresh.seq.find_item(c).unwrap().1;
            assert_eq!((trimmed.start, trimmed.duration, trimmed.source_in), (moved.start, moved.duration, moved.source_in), "{label}");
        }
    }
}