2026-10-01 22:36:31 -04:00
//! Tests for the menu-parity command families (Layer / Edit / Animation / File / Composition /
//! View menus), including undo.
use effectcraft_keyframe ::Value as KV ;
use effectcraft_project ::{ FrameBlend , ItemKind , MatteKind , Quality , Sampling };
use serde_json ::{ Value , json };
use crate ::{ EngineError , Event , Session };
fn comp () -> Session {
let mut s = Session ::default ();
s . execute ( "comp.new" , json! ({ "name" : "Main" , "width" : 640 , "height" : 360 , "frameRate" : 30 , "duration" : 10 })). unwrap ();
s
}
fn solid ( s : & mut Session , color : & str ) -> u64 {
s . execute ( "layer.newSolid" , json! ({ "color" : color , "width" : 200 , "height" : 100 })). unwrap ()[ "layer" ]. as_u64 (). unwrap ()
}
fn layer ( s : & Session , id : u64 ) -> effectcraft_project ::Layer {
s . active_comp (). unwrap (). layer ( effectcraft_project ::LayerId ( id )). unwrap (). clone ()
}
fn tmp ( name : & str ) -> String {
let d = std ::env ::temp_dir (). join ( format! ( "effectcraft-menu-tests- {} " , std ::process ::id ()));
std ::fs ::create_dir_all ( & d ). unwrap ();
d . join ( name ). to_string_lossy (). to_string ()
}
fn frontend_events ( s : & mut Session ) -> Vec < ( String , Value ) > {
s . drain_events ()
. into_iter ()
. filter_map ( | e | match e {
Event ::Frontend { command , params } => Some (( command , params )),
_ => None ,
})
. collect ()
}
#[test]
fn layer_quality_sampling_frame_blending_and_undo () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
s . execute ( "layer.quality" , json! ({ "quality" : "wireframe" })). unwrap ();
s . execute ( "layer.sampling" , json! ({ "sampling" : "bicubic" })). unwrap ();
s . execute ( "layer.frameBlending" , json! ({ "mode" : "pixelMotion" })). unwrap ();
let l = layer ( & s , a );
assert_eq! (( l . switches . quality , l . switches . sampling , l . switches . frame_blend ), ( Quality ::Wireframe , Sampling ::Bicubic , FrameBlend ::PixelMotion ));
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( layer ( & s , a ). switches . frame_blend , FrameBlend ::Off );
assert! ( s . execute ( "layer.quality" , json! ({ "quality" : "fancy" })). is_err ());
}
#[test]
fn layer_switches_menu () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
let b = solid ( & mut s , "#00ff00" );
s . execute ( "layer.select" , json! ({ "layers" : [ b ]})). unwrap ();
s . execute ( "layer.hideOtherVideo" , json! ({})). unwrap ();
assert! ( ! layer ( & s , a ). switches . video && layer ( & s , b ). switches . video );
s . execute ( "layer.showAllVideo" , json! ({})). unwrap ();
assert! ( layer ( & s , a ). switches . video );
s . execute ( "layer.setSwitch" , json! ({ "layers" : [ a , b ], "switch" : "lock" })). unwrap ();
assert! ( layer ( & s , a ). switches . locked );
s . execute ( "layer.unlockAll" , json! ({})). unwrap ();
assert! ( ! layer ( & s , a ). switches . locked && ! layer ( & s , b ). switches . locked );
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert! ( layer ( & s , a ). switches . locked );
// Expressions on / off.
s . execute ( "prop.setExpression" , json! ({ "layer" : a , "path" : "transform/opacity" , "expression" : "50" })). unwrap ();
s . execute ( "layer.expressions" , json! ({ "layers" : [ a ], "enabled" : false })). unwrap ();
assert! ( ! layer ( & s , a ). props . prop ( "transform/opacity" ). unwrap (). expr . as_ref (). unwrap (). enabled );
s . execute ( "layer.expressions" , json! ({ "layers" : [ a ], "enabled" : true })). unwrap ();
assert! ( layer ( & s , a ). props . prop ( "transform/opacity" ). unwrap (). has_expression ());
}
#[test]
fn transform_dialog_values_and_center_anchor () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
s . execute ( "layer.setTransform" , json! ({ "prop" : "position" , "value" : [ 100 , 50 ]})). unwrap ();
s . execute ( "layer.setTransform" , json! ({ "prop" : "rotation" , "value" : 90 })). unwrap ();
s . execute ( "layer.setTransform" , json! ({ "prop" : "opacity" , "value" : 25 })). unwrap ();
let l = layer ( & s , a );
assert_eq! ( l . props . prop ( "transform/position" ). unwrap (). value , KV ::Vec3 ([ 100.0 , 50.0 , 0.0 ]));
assert_eq! ( l . props . prop ( "transform/opacity" ). unwrap (). value . as_f64 (), 25.0 );
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( layer ( & s , a ). props . prop ( "transform/opacity" ). unwrap (). value . as_f64 (), 100.0 );
assert! ( s . execute ( "layer.setTransform" , json! ({ "prop" : "skew" , "value" : 1 })). is_err ());
// Move the anchor off-centre, then Center Anchor Point keeps the layer in place.
s . execute ( "layer.setTransform" , json! ({ "prop" : "anchor" , "value" : [ 0 , 0 ]})). unwrap ();
s . execute ( "layer.setTransform" , json! ({ "prop" : "rotation" , "value" : 0 })). unwrap ();
let before = layer ( & s , a ). props . prop ( "transform/position" ). unwrap (). value . as_vec3 ();
s . execute ( "layer.centerAnchor" , json! ({})). unwrap ();
let l = layer ( & s , a );
assert_eq! ( l . props . prop ( "transform/anchor" ). unwrap (). value . as_vec2 (), [ 100.0 , 50.0 ]);
let after = l . props . prop ( "transform/position" ). unwrap (). value . as_vec3 ();
assert! (( after [ 0 ] - before [ 0 ] - 100.0 ). abs () < 1e-6 && ( after [ 1 ] - before [ 1 ] - 50.0 ). abs () < 1e-6 , "{before:?} → {after:?}" );
s . execute ( "layer.autoOrient" , json! ({ "mode" : "alongPath" })). unwrap ();
assert_eq! ( layer ( & s , a ). auto_orient , effectcraft_project ::AutoOrient ::AlongPath );
}
#[test]
fn mask_menu_on_existing_masks () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
assert! ( ! s . is_enabled ( "layer.mask.reset" ));
s . execute ( "layer.addMask" , json! ({})). unwrap ();
s . execute ( "layer.addMask" , json! ({ "shape" : "ellipse" })). unwrap ();
assert! ( s . is_enabled ( "layer.mask.reset" ));
let masks = | s : & Session | layer ( s , a ). masks (). unwrap (). groups (). cloned (). collect ::< Vec < _ >> ();
s . execute ( "layer.mask.set" , json! ({ "field" : "feather" , "value" : 12 , "mask" : 1 })). unwrap ();
assert_eq! ( masks ( & s )[ 0 ]. get ( "feather" ). unwrap (). value , KV ::Vec2 ([ 12.0 , 12.0 ]));
s . execute ( "layer.mask.set" , json! ({ "field" : "opacity" , "value" : 40 })). unwrap ();
assert! ( masks ( & s ). iter (). all ( | m | m . get ( "opacity" ). unwrap (). value . as_f64 () == 40.0 ));
s . execute ( "layer.mask.invert" , json! ({ "mask" : 2 })). unwrap ();
s . execute ( "layer.mask.mode" , json! ({ "mode" : "Subtract" , "mask" : 2 })). unwrap ();
s . execute ( "layer.mask.lock" , json! ({ "mask" : 1 })). unwrap ();
let kinds : Vec < _ > = masks ( & s ). iter (). map ( | m | m . kind . clone ()). collect ();
assert! ( matches! ( kinds [ 1 ], effectcraft_project ::GroupKind ::Mask { inverted : true , mode : effectcraft_project ::MaskMode ::Subtract , .. }));
assert! ( matches! ( kinds [ 0 ], effectcraft_project ::GroupKind ::Mask { locked : true , .. }));
s . execute ( "layer.mask.unlockAll" , json! ({})). unwrap ();
assert! ( matches! ( masks ( & s )[ 0 ]. kind , effectcraft_project ::GroupKind ::Mask { locked : false , .. }));
s . execute ( "layer.mask.lockOthers" , json! ({ "mask" : 1 })). unwrap ();
assert! ( matches! ( masks ( & s )[ 1 ]. kind , effectcraft_project ::GroupKind ::Mask { locked : true , .. }));
s . execute ( "layer.mask.reset" , json! ({ "mask" : 1 })). unwrap ();
assert_eq! ( masks ( & s )[ 0 ]. get ( "opacity" ). unwrap (). value . as_f64 (), 100.0 );
s . execute ( "layer.mask.shape" , json! ({ "mask" : 1 , "rect" : [ 10 , 10 , 50 , 40 ], "shape" : "ellipse" })). unwrap ();
s . execute ( "layer.mask.remove" , json! ({ "mask" : 2 })). unwrap ();
assert_eq! ( masks ( & s ). len (), 1 );
s . execute ( "layer.mask.removeAll" , json! ({})). unwrap ();
assert! ( masks ( & s ). is_empty ());
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( masks ( & s ). len (), 1 );
}
#[test]
fn layer_markers_lock_and_delete () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
s . execute ( "time.set" , json! ({ "time" : 1.0 })). unwrap ();
s . execute ( "layer.addMarker" , json! ({ "comment" : "hit" })). unwrap ();
s . execute ( "layer.addMarker" , json! ({ "time" : 2.0 })). unwrap ();
assert_eq! ( layer ( & s , a ). markers . len (), 2 );
s . execute ( "layer.markersLock" , json! ({})). unwrap ();
assert! ( layer ( & s , a ). markers_locked );
s . execute ( "layer.deleteAllMarkers" , json! ({})). unwrap ();
assert_eq! ( layer ( & s , a ). markers . len (), 2 , "locked markers survive" );
s . execute ( "layer.markersLock" , json! ({ "value" : false })). unwrap ();
s . execute ( "layer.deleteAllMarkers" , json! ({})). unwrap ();
assert! ( layer ( & s , a ). markers . is_empty ());
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( layer ( & s , a ). markers . len (), 2 );
}
#[test]
fn track_matte_menu () {
let mut s = comp ();
let below = solid ( & mut s , "#ff0000" );
let top = solid ( & mut s , "#00ff00" );
s . execute ( "layer.select" , json! ({ "layers" : [ below ]})). unwrap ();
s . execute ( "layer.trackMatte" , json! ({ "op" : "luma" })). unwrap ();
let m = layer ( & s , below ). track_matte . unwrap ();
assert_eq! (( m . layer . 0 , m . kind ), ( top , MatteKind ::Luma ));
assert! ( ! layer ( & s , top ). switches . video );
s . execute ( "layer.trackMatte" , json! ({ "op" : "alphaInverted" })). unwrap ();
assert_eq! ( layer ( & s , below ). track_matte . unwrap (). kind , MatteKind ::AlphaInverted );
s . execute ( "layer.trackMatte" , json! ({ "op" : "none" })). unwrap ();
assert! ( layer ( & s , below ). track_matte . is_none ());
s . execute ( "layer.select" , json! ({ "layers" : [ top ]})). unwrap ();
assert! ( s . execute ( "layer.trackMatte" , json! ({ "op" : "above" })). is_err ());
s . execute ( "layer.trackMatte" , json! ({ "op" : "below" })). unwrap ();
assert_eq! ( layer ( & s , top ). track_matte . unwrap (). layer . 0 , below );
}
#[test]
fn keyframe_clipboard_paste_and_paste_reversed () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
let b = solid ( & mut s , "#00ff00" );
s . execute ( "prop.toggleAnimation" , json! ({ "layer" : a , "path" : "transform/opacity" })). unwrap ();
s . execute ( "time.set" , json! ({ "time" : 1.0 })). unwrap ();
s . execute ( "prop.set" , json! ({ "layer" : a , "path" : "transform/opacity" , "value" : 0 })). unwrap ();
s . execute ( "prop.select" , json! ({ "layer" : a , "path" : "transform/opacity" })). unwrap ();
2026-10-02 00:12:01 -04:00
s . execute ( "edit.copy" , json! ({})). unwrap ();
assert_eq! ( s . state . key_clipboard . iter (). map ( | c | c . keys . len ()). sum ::< usize > (), 2 );
2026-10-01 22:36:31 -04:00
s . execute ( "layer.select" , json! ({ "layers" : [ b ]})). unwrap ();
s . execute ( "time.set" , json! ({ "time" : 2.0 })). unwrap ();
s . execute ( "edit.paste" , json! ({})). unwrap ();
let keys = layer ( & s , b ). props . prop ( "transform/opacity" ). unwrap (). keys . clone ();
assert_eq! ( keys . len (), 2 );
assert! (( keys [ 0 ]. time . seconds () - 2.0 ). abs () < 1e-6 && keys [ 0 ]. value . as_f64 () == 100.0 );
s . execute ( "edit.undo" , json! ({})). unwrap ();
s . execute ( "edit.pasteReversedKeyframes" , json! ({})). unwrap ();
let keys = layer ( & s , b ). props . prop ( "transform/opacity" ). unwrap (). keys . clone ();
assert_eq! (( keys [ 0 ]. value . as_f64 (), keys [ 1 ]. value . as_f64 ()), ( 0.0 , 100.0 ));
}
#[test]
fn property_links_and_expression_only () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
let b = solid ( & mut s , "#00ff00" );
s . execute ( "prop.select" , json! ({ "layer" : a , "path" : "transform/position" })). unwrap ();
s . execute ( "edit.copyWithPropertyLinks" , json! ({})). unwrap ();
s . execute ( "layer.select" , json! ({ "layers" : [ b ]})). unwrap ();
s . execute ( "edit.paste" , json! ({})). unwrap ();
let e = layer ( & s , b ). props . prop ( "transform/position" ). unwrap (). expr . clone (). unwrap ();
let name = layer ( & s , a ). name ;
assert_eq! ( e . text , format! ( "comp( \" Main \" ).layer( {} ).transform( \" Position \" )" , serde_json ::to_string ( & name ). unwrap ()));
// Relative links use thisComp.
s . execute ( "prop.select" , json! ({ "layer" : a , "path" : "transform/opacity" })). unwrap ();
s . execute ( "edit.copyWithRelativePropertyLinks" , json! ({})). unwrap ();
s . execute ( "layer.select" , json! ({ "layers" : [ b ]})). unwrap ();
s . execute ( "edit.paste" , json! ({})). unwrap ();
assert! ( layer ( & s , b ). props . prop ( "transform/opacity" ). unwrap (). expr . as_ref (). unwrap (). text . starts_with ( "thisComp.layer(" ));
// Copy Expression Only.
s . execute ( "prop.setExpression" , json! ({ "layer" : a , "path" : "transform/rotation" , "expression" : "time * 90" })). unwrap ();
s . execute ( "prop.select" , json! ({ "layer" : a , "path" : "transform/rotation" })). unwrap ();
s . execute ( "edit.copyExpressionOnly" , json! ({})). unwrap ();
s . execute ( "layer.select" , json! ({ "layers" : [ b ]})). unwrap ();
s . execute ( "edit.paste" , json! ({})). unwrap ();
assert_eq! ( layer ( & s , b ). props . prop ( "transform/rotation" ). unwrap (). expr . as_ref (). unwrap (). text , "time * 90" );
// Layers with property links: the pasted copy follows the original.
s . state . selected_props . clear ();
s . execute ( "layer.select" , json! ({ "layers" : [ a ]})). unwrap ();
s . execute ( "edit.copyWithPropertyLinks" , json! ({})). unwrap ();
let new = s . execute ( "edit.paste" , json! ({})). unwrap ();
let nid = new [ 0 ]. as_u64 (). unwrap ();
assert! ( layer ( & s , nid ). props . prop ( "transform/scale" ). unwrap (). has_expression ());
}
#[test]
fn lift_and_extract_work_area () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
s . execute ( "comp.workArea" , json! ({ "start" : 2.0 , "end" : 4.0 })). unwrap ();
s . execute ( "edit.liftWorkArea" , json! ({})). unwrap ();
let c = s . active_comp (). unwrap ();
assert_eq! ( c . layers . len (), 2 , "split around the gap" );
let mut spans : Vec < ( f64 , f64 ) > = c . layers . iter (). map ( | l | ( l . in_point . seconds (), l . out_point . seconds ())). collect ();
spans . sort_by ( | x , y | x . 0. total_cmp ( & y . 0 ));
assert! (( spans [ 0 ]. 1 - 2.0 ). abs () < 1e-6 && ( spans [ 1 ]. 0 - 4.0 ). abs () < 1e-6 );
s . execute ( "edit.undo" , json! ({})). unwrap ();
s . execute ( "layer.select" , json! ({ "layers" : [ a ]})). unwrap ();
s . execute ( "edit.extractWorkArea" , json! ({})). unwrap ();
let c = s . active_comp (). unwrap ();
let mut spans : Vec < ( f64 , f64 ) > = c . layers . iter (). map ( | l | ( l . in_point . seconds (), l . out_point . seconds ())). collect ();
spans . sort_by ( | x , y | x . 0. total_cmp ( & y . 0 ));
assert! (( spans [ 1 ]. 0 - 2.0 ). abs () < 1e-6 && ( spans [ 1 ]. 1 - 8.0 ). abs () < 1e-6 , "{spans:?}" );
}
#[test]
fn label_group_purge_and_edit_original () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
let b = solid ( & mut s , "#00ff00" );
let _c = solid ( & mut s , "#0000ff" );
s . execute ( "edit.label" , json! ({ "layers" : [ a , b ], "label" : "Cyan" })). unwrap ();
s . execute ( "layer.select" , json! ({ "layers" : [ a ]})). unwrap ();
s . execute ( "edit.selectLabelGroup" , json! ({})). unwrap ();
assert_eq! ( s . state . selected_layers . len (), 2 );
2026-10-05 01:03:47 +07:00
// A footage source that counts purges (the media pool drops its decoded frames).
struct Counting ( std ::sync ::atomic ::AtomicUsize );
impl crate ::render ::FootageSource for Counting {
fn frame (
& self ,
_ : effectcraft_project ::ItemId ,
_ : & effectcraft_project ::Footage ,
_ : effectcraft_time ::Tick ,
) -> Option < std ::sync ::Arc < crate ::render ::Image >> {
None
}
fn purge ( & self ) {
self . 0. fetch_add ( 1 , std ::sync ::atomic ::Ordering ::SeqCst );
}
}
let src = std ::sync ::Arc ::new ( Counting ( Default ::default ()));
s . footage = src . clone ();
2026-10-01 22:36:31 -04:00
s . drain_events ();
s . execute ( "edit.purge" , json! ({ "what" : "memory" })). unwrap ();
assert! ( s . drain_events (). contains ( & Event ::PurgeCaches ));
2026-10-05 01:03:47 +07:00
assert_eq! ( src . 0. load ( std ::sync ::atomic ::Ordering ::SeqCst ), 1 , "decoded footage frames are dropped" );
// The disk cache and the snapshot purge alone: the RAM preview stays.
for what in [ "disk" , "snapshot" ] {
s . execute ( "edit.purge" , json! ({ "what" : what })). unwrap ();
assert! ( ! s . drain_events (). contains ( & Event ::PurgeCaches ), "{what}" );
}
assert_eq! ( src . 0. load ( std ::sync ::atomic ::Ordering ::SeqCst ), 1 );
s . execute ( "edit.purge" , json! ({ "what" : "3d" })). unwrap ();
assert! ( s . drain_events (). contains ( & Event ::PurgeCaches ));
2026-10-01 22:36:31 -04:00
assert! ( ! s . is_enabled ( "edit.editOriginal" ));
}
#[test]
fn animation_menu_keys_presets_text () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
// Add Keyframe on selected properties.
s . execute ( "prop.select" , json! ({ "layer" : a , "path" : "transform/scale" })). unwrap ();
s . execute ( "anim.addKeyframe" , json! ({})). unwrap ();
s . execute ( "time.set" , json! ({ "time" : 1.0 })). unwrap ();
s . execute ( "prop.set" , json! ({ "layer" : a , "path" : "transform/scale" , "value" : [ 400 , 400 ]})). unwrap ();
assert_eq! ( layer ( & s , a ). props . prop ( "transform/scale" ). unwrap (). keys . len (), 2 );
// Exponential Scale: a key per frame, geometric in between.
s . execute ( "prop.select" , json! ({ "layer" : a , "path" : "transform/scale" })). unwrap ();
s . execute ( "keys.exponentialScale" , json! ({})). unwrap ();
let keys = layer ( & s , a ). props . prop ( "transform/scale" ). unwrap (). keys . clone ();
assert_eq! ( keys . len (), 31 );
assert! (( keys [ 15 ]. value . as_vec3 ()[ 0 ] - 200.0 ). abs () < 1e-6 , "{:?}" , keys [ 15 ]. value );
s . execute ( "edit.undo" , json! ({})). unwrap ();
// Time-Reverse Keyframes.
s . execute ( "prop.select" , json! ({ "layer" : a , "path" : "transform/scale" })). unwrap ();
s . execute ( "keys.timeReverse" , json! ({})). unwrap ();
let keys = layer ( & s , a ). props . prop ( "transform/scale" ). unwrap (). keys . clone ();
assert_eq! (( keys [ 0 ]. value . as_vec3 ()[ 0 ], keys [ 1 ]. value . as_vec3 ()[ 0 ]), ( 400.0 , 100.0 ));
// Presets round-trip through a file onto another layer at the CTI.
let path = tmp ( "scale.ecpreset" );
s . execute ( "prop.select" , json! ({ "layer" : a , "path" : "transform/scale" })). unwrap ();
s . execute ( "anim.savePreset" , json! ({ "path" : path })). unwrap ();
let b = solid ( & mut s , "#00ff00" );
s . execute ( "time.set" , json! ({ "time" : 3.0 })). unwrap ();
let r = s . execute ( "anim.applyPreset" , json! ({ "path" : path , "layers" : [ b ]})). unwrap ();
assert_eq! ( r [ "applied" ], 1 );
let keys = layer ( & s , b ). props . prop ( "transform/scale" ). unwrap (). keys . clone ();
assert_eq! ( keys . len (), 2 );
assert! (( keys [ 0 ]. time . seconds () - 3.0 ). abs () < 1e-6 );
// Text: animate, add selector, reveal, remove all.
let t = s . execute ( "layer.newText" , json! ({ "text" : "Hi" })). unwrap ()[ "layer" ]. as_u64 (). unwrap ();
s . execute ( "layer.addTextAnimator" , json! ({ "properties" : [ "anchor" , "position" , "scale" , "skew" , "rotation" , "opacity" ]})). unwrap ();
s . execute ( "text.addSelector" , json! ({ "kind" : "range" })). unwrap ();
let anim = layer ( & s , t ). props . group ( "text/animators" ). unwrap (). groups (). next (). unwrap (). clone ();
assert_eq! ( anim . sub ( "selectors" ). unwrap (). children . len (), 2 );
2026-10-02 00:44:20 -04:00
// Skew brings Skew Axis along.
assert_eq! ( anim . sub ( "properties" ). unwrap (). children . len (), 7 );
s . execute ( "text.addSelector" , json! ({ "kind" : "wiggly" })). unwrap ();
assert! ( s . execute ( "text.addSelector" , json! ({ "kind" : "other" })). is_err ());
2026-10-01 22:36:31 -04:00
s . execute ( "text.removeAllAnimators" , json! ({})). unwrap ();
assert! ( layer ( & s , t ). props . group ( "text/animators" ). unwrap (). children . is_empty ());
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( layer ( & s , t ). props . group ( "text/animators" ). unwrap (). children . len (), 1 );
}
#[test]
fn reveal_properties () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
s . execute ( "prop.toggleAnimation" , json! ({ "layer" : a , "path" : "transform/rotation" })). unwrap ();
s . execute ( "prop.setExpression" , json! ({ "layer" : a , "path" : "transform/opacity" , "expression" : "50" })). unwrap ();
s . execute ( "prop.set" , json! ({ "layer" : a , "path" : "transform/scale" , "value" : [ 50 , 50 ]})). unwrap ();
s . drain_events ();
let n = | v : & Value | v [ "props" ]. as_array (). unwrap (). len ();
assert_eq! ( n ( & s . execute ( "anim.reveal" , json! ({ "kind" : "keyframes" })). unwrap ()), 1 );
assert_eq! ( n ( & s . execute ( "anim.reveal" , json! ({ "kind" : "animation" })). unwrap ()), 2 );
assert_eq! ( n ( & s . execute ( "anim.reveal" , json! ({ "kind" : "modified" })). unwrap ()), 3 );
assert! ( frontend_events ( & mut s ). iter (). all ( | ( c , _ ) | c == "timeline.revealProps" ));
}
#[test]
fn sequence_layers () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
let b = solid ( & mut s , "#00ff00" );
let c = solid ( & mut s , "#0000ff" );
for ( id , out ) in [( a , 2.0 ), ( b , 3.0 ), ( c , 1.0 )] {
s . execute ( "layer.timing" , json! ({ "layers" : [ id ], "out" : out })). unwrap ();
}
s . execute ( "layer.sequence" , json! ({ "layers" : [ a , b , c ], "overlap" : true , "duration" : 0.5 , "transition" : "dissolveFront" })). unwrap ();
assert! (( layer ( & s , b ). in_point . seconds () - 1.5 ). abs () < 1e-6 );
assert! (( layer ( & s , c ). in_point . seconds () - 4.0 ). abs () < 1e-6 );
assert_eq! ( layer ( & s , c ). props . prop ( "transform/opacity" ). unwrap (). keys . len (), 2 );
}
#[test]
fn file_menu_project_ops () {
let mut s = comp ();
let f = s . execute ( "project.newFolder" , json! ({ "name" : "Stuff" })). unwrap ()[ "item" ]. as_u64 (). unwrap ();
assert! ( s . project . item ( effectcraft_project ::ItemId ( f )). unwrap (). is_folder ());
let p1 = s . execute ( "file.importPlaceholder" , json! ({ "name" : "Shot 1" , "width" : 320 , "height" : 240 })). unwrap ()[ "item" ]. as_u64 (). unwrap ();
let p2 = s . execute ( "file.importPlaceholder" , json! ({ "name" : "Unused" })). unwrap ()[ "item" ]. as_u64 (). unwrap ();
s . execute ( "file.importSolid" , json! ({ "name" : "Grey" })). unwrap ();
s . state . project_selection = vec! [ effectcraft_project ::ItemId ( p1 )];
let r = s . execute ( "file.newCompFromSelection" , json! ({})). unwrap ();
let nc = effectcraft_project ::ItemId ( r [ "comps" ][ 0 ]. as_u64 (). unwrap ());
assert_eq! (( s . project . comp ( nc ). unwrap (). width , s . project . comp ( nc ). unwrap (). layers . len ()), ( 320 , 1 ));
// Missing footage = the placeholders.
let miss = s . execute ( "file.findMissing" , json! ({ "what" : "footage" })). unwrap ();
assert_eq! ( miss [ "items" ]. as_array (). unwrap (). len (), 2 );
assert! ( s . execute ( "file.findMissing" , json! ({ "what" : "fonts" })). is_ok ());
// Interpretation.
s . state . project_selection = vec! [ effectcraft_project ::ItemId ( p1 )];
s . execute ( "file.interpretFootage" , json! ({ "frameRate" : 24 , "alpha" : "premultiplied" , "loop" : 3 })). unwrap ();
s . execute ( "file.rememberInterpretation" , json! ({})). unwrap ();
s . state . project_selection = vec! [ effectcraft_project ::ItemId ( p2 )];
s . execute ( "file.applyInterpretation" , json! ({})). unwrap ();
match & s . project . item ( effectcraft_project ::ItemId ( p2 )). unwrap (). kind {
ItemKind ::Footage ( f ) => assert_eq! (( f . alpha , f . loop_count , f . frame_rate . as_f64 (). round ()), ( effectcraft_project ::AlphaMode ::Premultiplied , 3 , 24.0 )),
_ => panic! (),
}
// Remove Unused Footage drops the unused placeholder and the unused solid.
let before = s . project . items . len ();
s . execute ( "file.removeUnusedFootage" , json! ({})). unwrap ();
assert_eq! ( s . project . items . len (), before - 2 );
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( s . project . items . len (), before );
// Replace with a solid retargets the layer.
s . state . project_selection = vec! [ effectcraft_project ::ItemId ( p1 )];
s . execute ( "file.replaceWithSolid" , json! ({ "color" : "#336699" })). unwrap ();
assert! ( matches! ( s . project . comp ( nc ). unwrap (). layers [ 0 ]. source , effectcraft_project ::LayerSource ::Solid { .. }));
// Reduce Project keeps only the selected comp and what it uses (+ folders of kept items).
s . state . project_selection = vec! [ nc ];
s . execute ( "file.reduceProject" , json! ({})). unwrap ();
assert! ( s . project . items . len () <= 2 , "{:?}" , s . project . items . values (). map ( | i | & i . name ). collect ::< Vec < _ >> ());
// Save a copy leaves the session path alone.
let path = tmp ( "copy.ecproj" );
s . execute ( "file.saveCopy" , json! ({ "path" : path })). unwrap ();
assert! ( s . path . is_none () && std ::fs ::metadata ( & path ). is_ok ());
s . execute ( "file.closeProject" , json! ({})). unwrap ();
assert! ( s . project . items . is_empty ());
}
#[test]
fn consolidate_duplicate_footage () {
let mut s = comp ();
let f = | s : & mut Session | s . execute ( "file.importPlaceholder" , json! ({})). unwrap ()[ "item" ]. as_u64 (). unwrap ();
let a = f ( & mut s );
let b = f ( & mut s );
// Give both the same file path.
let mut p = ( * s . project ). clone ();
for id in [ a , b ] {
if let Some ( ItemKind ::Footage ( ft )) = p . item_mut ( effectcraft_project ::ItemId ( id )). map ( | i | & mut i . kind ) {
ft . path = "/media/shot.mov" . into ();
}
}
s . project = std ::sync ::Arc ::new ( p );
s . execute ( "layer.addItem" , json! ({ "item" : b })). unwrap ();
assert_eq! ( s . execute ( "file.consolidateFootage" , json! ({})). unwrap ()[ "removed" ], 1 );
let c = s . active_comp (). unwrap ();
assert_eq! ( c . layers [ 0 ]. source . item (). unwrap (). 0 , a );
}
#[test]
fn run_script_steps () {
let mut s = comp ();
let path = tmp ( "script.jsonl" );
std ::fs ::write ( & path , "// make two solids \n { \" command \" : \" layer.newSolid \" , \" params \" :{ \" color \" : \" #ff0000 \" }} \n { \" method \" : \" engine.execute \" , \" params \" :{ \" id \" : \" layer.newNull \" , \" params \" :{}}} \n " ). unwrap ();
let r = s . execute ( "file.runScript" , json! ({ "path" : path })). unwrap ();
assert_eq! ( r [ "steps" ], 2 );
assert_eq! ( s . active_comp (). unwrap (). layers . len (), 2 );
assert! ( s . execute ( "file.runScript" , json! ({ "steps" : [{ "command" : "nope.nope" }]})). is_err ());
}
#[test]
fn crop_comp_and_save_frame () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
// ROI crop moves layers so nothing shifts on screen.
assert! ( ! s . is_enabled ( "comp.cropToRegionOfInterest" ));
s . execute ( "view.setRegionOfInterest" , json! ({ "rect" : [ 100 , 50 , 200 , 100 ]})). unwrap ();
s . execute ( "comp.cropToRegionOfInterest" , json! ({})). unwrap ();
let c = s . active_comp (). unwrap ();
assert_eq! (( c . width , c . height ), ( 200 , 100 ));
assert_eq! ( layer ( & s , a ). props . prop ( "transform/position" ). unwrap (). value . as_vec2 (), [ 220.0 , 130.0 ]);
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( s . active_comp (). unwrap (). width , 640 );
// Crop to the selected layer's bounds (a 200× 100 solid centred in 640× 360).
s . execute ( "layer.select" , json! ({ "layers" : [ a ]})). unwrap ();
let r = s . execute ( "comp.cropToLayerBounds" , json! ({})). unwrap ();
assert_eq! (( r [ "width" ]. as_u64 (), r [ "height" ]. as_u64 ()), ( Some ( 200 ), Some ( 100 )));
assert_eq! ( layer ( & s , a ). props . prop ( "transform/position" ). unwrap (). value . as_vec2 (), [ 100.0 , 50.0 ]);
// Save Frame As ▸ File… writes a PNG.
let path = tmp ( "frame.png" );
let r = s . execute ( "comp.saveFrameAs" , json! ({ "path" : path , "scale" : 0.5 })). unwrap ();
assert_eq! ( r [ "width" ], 100 );
let bytes = std ::fs ::read ( & path ). unwrap ();
assert_eq! ( & bytes [ .. 8 ], b " \x89 PNG \r\n\x1a\n " );
// Responsive Design — Time.
s . execute ( "time.set" , json! ({ "time" : 2.0 })). unwrap ();
s . execute ( "comp.responsiveTime" , json! ({ "op" : "intro" })). unwrap ();
let m = & s . active_comp (). unwrap (). markers [ 0 ];
assert! ( m . protected && ( m . duration . seconds () - 2.0 ). abs () < 1e-6 );
}
#[test]
fn guides_add_clear_import_export () {
let mut s = comp ();
s . execute ( "view.addGuide" , json! ({ "orientation" : "horizontal" , "position" : 40 })). unwrap ();
s . execute ( "view.addGuide" , json! ({})). unwrap ();
assert_eq! ( s . active_comp (). unwrap (). guides . len (), 2 );
assert_eq! ( s . active_comp (). unwrap (). guides [ 1 ]. position , 320.0 );
let path = tmp ( "guides.json" );
s . execute ( "view.exportGuides" , json! ({ "path" : path })). unwrap ();
s . execute ( "view.clearGuides" , json! ({})). unwrap ();
assert! ( s . active_comp (). unwrap (). guides . is_empty ());
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( s . active_comp (). unwrap (). guides . len (), 2 );
s . execute ( "view.clearGuides" , json! ({})). unwrap ();
s . execute ( "view.importGuides" , json! ({ "path" : path })). unwrap ();
assert_eq! ( s . active_comp (). unwrap (). guides . len (), 2 );
}
#[test]
fn frontend_commands_emit_events_and_stubs_are_disabled () {
let mut s = comp ();
s . drain_events ();
s . execute ( "view.zoomIn" , json! ({})). unwrap ();
s . execute ( "window.panel" , json! ({ "panel" : "align" })). unwrap ();
let ev = frontend_events ( & mut s );
assert_eq! ( ev [ 0 ]. 0 , "view.zoomIn" );
assert_eq! ( ev [ 1 ], ( "window.panel" . to_string (), json! ({ "panel" : "align" })));
2026-10-03 03:29:39 -04:00
for id in [ "layer.autoTrace" , "layer.sceneEditDetection" , "layer.create" , "track.motion" ] {
2026-10-01 22:36:31 -04:00
assert! ( ! s . is_enabled ( id ), "{id}" );
assert! ( matches! ( s . execute ( id , json! ({})), Err ( EngineError ::Disabled ( .. ))), "{id}" );
}
}
2026-10-04 23:22:09 +07:00
fn solid_of ( s : & Session , l : u64 ) -> ( u64 , effectcraft_project ::Solid , String ) {
let effectcraft_project ::LayerSource ::Solid { item } = layer ( s , l ). source else { panic! ( "not a solid" ) };
let it = s . project . item ( item ). unwrap ();
let ItemKind ::Solid ( so ) = & it . kind else { panic! ( "not a solid item" ) };
( item . 0 , so . clone (), it . name . clone ())
}
#[test]
fn layer_settings_edit_the_solid_or_give_the_layer_its_own () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
s . execute ( "layer.select" , json! ({ "layers" : [ a ]})). unwrap ();
let b = s . execute ( "edit.duplicate" , json! ({})). unwrap ()[ 0 ]. as_u64 (). unwrap ();
assert_eq! ( solid_of ( & s , a ). 0 , solid_of ( & s , b ). 0 , "the duplicate shares the solid" );
// Nothing given: nothing recorded.
let steps = s . history . undo . len ();
s . execute ( "layer.settings" , json! ({ "layer" : b })). unwrap ();
assert_eq! ( s . history . undo . len (), steps );
// Affect all off: the duplicate gets its own solid; the original keeps its colour.
let r = s . execute ( "layer.settings" , json! ({ "layer" : b , "color" : "#0000ff" , "name" : "Blue" , "affectAll" : false })). unwrap ();
let ( bi , bs , bn ) = solid_of ( & s , b );
assert_eq! ( r , json! ({ "layer" : b , "solid" : bi }));
assert_ne! ( bi , solid_of ( & s , a ). 0 );
assert_eq! (( bs . color , bn . as_str (), layer ( & s , b ). name . as_str ()), ([ 0.0 , 0.0 , 1.0 ], "Blue" , "Blue" ));
assert_eq! ( solid_of ( & s , a ). 1. color , [ 1.0 , 0.0 , 0.0 ]);
assert_eq! (
s . project . item ( effectcraft_project ::ItemId ( bi )). unwrap (). parent ,
s . project . item ( effectcraft_project ::ItemId ( solid_of ( & s , a ). 0 )). unwrap (). parent ,
"same folder"
);
// Affect all (the default) changes the shared solid in place; size and pixel aspect too.
s . execute ( "layer.select" , json! ({ "layers" : [ a ]})). unwrap ();
let c = s . execute ( "edit.duplicate" , json! ({})). unwrap ()[ 0 ]. as_u64 (). unwrap ();
s . execute ( "layer.settings" , json! ({ "layer" : a , "width" : 320 , "height" : 90 , "pixelAspect" : 2.0 })). unwrap ();
assert_eq! ( solid_of ( & s , a ). 0 , solid_of ( & s , c ). 0 );
let so = solid_of ( & s , c ). 1 ;
assert_eq! (( so . width , so . height , so . pixel_aspect ), ( 320 , 90 , 2.0 ));
assert! ( s . execute ( "layer.settings" , json! ({ "layer" : a , "pixelAspect" : 0 })). is_err ());
// One undo step each.
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( solid_of ( & s , a ). 1. width , 200 );
// A new solid takes a pixel aspect too.
let d = s . execute ( "layer.newSolid" , json! ({ "color" : "#00ff00" , "pixelAspect" : 0.9091 })). unwrap ()[ "layer" ]. as_u64 (). unwrap ();
assert_eq! ( solid_of ( & s , d ). 1. pixel_aspect , 0.9091 );
// Text and shape layers have no settings.
assert! ( s . is_enabled ( "layer.settings" ));
s . execute ( "layer.newText" , json! ({ "text" : "T" })). unwrap ();
assert! ( ! s . is_enabled ( "layer.settings" ));
}
2026-10-04 23:33:54 +07:00
fn order ( s : & Session ) -> Vec < u64 > {
s . active_comp (). unwrap (). layers . iter (). map ( | l | l . id . 0 ). collect ()
}
fn pos ( s : & Session , l : u64 ) -> [ f64 ; 3 ] {
let ly = layer ( s , l );
let tr = ly . transform (). unwrap ();
match tr . get ( "positionX" ) {
Some ( x ) => [ x . value . as_f64 (), tr . get ( "positionY" ). unwrap (). value . as_f64 (), tr . get ( "positionZ" ). map ( | z | z . value . as_f64 ()). unwrap_or ( 0.0 )],
None => tr . get ( "position" ). unwrap (). value . as_vec3 (),
}
}
#[test]
fn locked_layers_are_not_selected_deleted_or_moved () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
let b = solid ( & mut s , "#00ff00" );
s . execute ( "layer.setSwitch" , json! ({ "layers" : [ b ], "switch" : "lock" , "value" : true })). unwrap ();
assert! ( layer ( & s , b ). switches . locked );
s . execute ( "edit.selectAll" , json! ({})). unwrap ();
assert_eq! ( s . state . selected_layers . iter (). map ( | l | l . 0 ). collect ::< Vec < _ >> (), vec! [ a ]);
// Ctrl+Up / Down step over it.
s . execute ( "layer.select" , json! ({ "layers" : [ a ]})). unwrap ();
s . execute ( "layer.selectPrevious" , json! ({})). unwrap ();
assert_eq! ( s . state . selected_layers [ 0 ]. 0 , a , "nothing above the locked layer to step to" );
// Deleting, arranging or transforming only the locked layer is refused; with others, it stays.
let e = s . execute ( "edit.clear" , json! ({ "layers" : [ b ]})). unwrap_err (). to_string ();
assert! ( e . contains ( "locked" ), "{e}" );
assert! ( s . execute ( "layer.arrange" , json! ({ "layers" : [ b ], "to" : "back" })). is_err ());
assert! ( s . execute ( "layer.transform" , json! ({ "layers" : [ b ], "op" : "center" })). is_err ());
s . execute ( "edit.clear" , json! ({ "layers" : [ a , b ]})). unwrap ();
assert_eq! ( order ( & s ), vec! [ b ]);
}
#[test]
fn deleting_a_parent_keeps_its_children_in_place () {
let mut s = comp ();
let parent = solid ( & mut s , "#ff0000" );
s . execute ( "prop.set" , json! ({ "layer" : parent , "path" : "transform/position" , "value" : [ 300 , 200 ]})). unwrap ();
s . execute ( "prop.set" , json! ({ "layer" : parent , "path" : "transform/rotation" , "value" : 90 })). unwrap ();
let child = solid ( & mut s , "#00ff00" );
s . execute ( "prop.set" , json! ({ "layer" : child , "path" : "transform/position" , "value" : [ 210 , 160 ]})). unwrap ();
s . execute ( "layer.setParent" , json! ({ "layers" : [ child ], "parent" : parent })). unwrap ();
assert_ne! ( pos ( & s , child )[ .. 2 ], [ 210.0 , 160.0 ], "expressed in the parent's space" );
s . execute ( "edit.clear" , json! ({ "layers" : [ parent ]})). unwrap ();
let p = pos ( & s , child );
assert! (( p [ 0 ] - 210.0 ). abs () < 1e-6 && ( p [ 1 ] - 160.0 ). abs () < 1e-6 , "{p:?}" );
assert_eq! ( layer ( & s , child ). parent , None );
let r = layer ( & s , child ). transform (). unwrap (). get ( "rotation" ). unwrap (). value . as_f64 ();
assert! ( r . abs () < 1e-6 , "{r}" );
// One undo step restores both.
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( layer ( & s , child ). parent . map ( | l | l . 0 ), Some ( parent ));
}
#[test]
fn bring_forward_and_send_backward_move_each_layer_one_step () {
let mut s = comp ();
let ids : Vec < u64 > = ( 0 .. 4 ). map ( | _ | solid ( & mut s , "#ffffff" )). collect ();
let top = order ( & s );
assert_eq! ( top , ids . iter (). rev (). copied (). collect ::< Vec < _ >> ());
let ( l0 , l1 , l2 , l3 ) = ( top [ 0 ], top [ 1 ], top [ 2 ], top [ 3 ]);
// A non-contiguous selection: each moves down one step.
s . execute ( "layer.arrange" , json! ({ "layers" : [ l0 , l2 ], "to" : "backward" })). unwrap ();
assert_eq! ( order ( & s ), vec! [ l1 , l0 , l3 , l2 ]);
// Forward again; a layer already at the top stays there.
s . execute ( "layer.arrange" , json! ({ "layers" : [ l0 , l2 ], "to" : "forward" })). unwrap ();
assert_eq! ( order ( & s ), vec! [ l0 , l1 , l2 , l3 ]);
s . execute ( "layer.arrange" , json! ({ "layers" : [ l0 , l2 ], "to" : "forward" })). unwrap ();
assert_eq! ( order ( & s ), vec! [ l0 , l2 , l1 , l3 ]);
// Front / Back keep the layers' order.
s . execute ( "layer.arrange" , json! ({ "layers" : [ l0 , l1 ], "to" : "back" })). unwrap ();
assert_eq! ( order ( & s ), vec! [ l2 , l3 , l0 , l1 ]);
}
#[test]
fn transform_commands_keep_depth_and_follow_separated_dimensions () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
s . execute ( "layer.setSwitch" , json! ({ "layers" : [ a ], "switch" : "threeD" , "value" : true })). unwrap ();
s . execute ( "prop.set" , json! ({ "layer" : a , "path" : "transform/position" , "value" : [ 10 , 20 , - 300 ]})). unwrap ();
s . execute ( "layer.transform" , json! ({ "layers" : [ a ], "op" : "center" })). unwrap ();
assert_eq! ( pos ( & s , a ), [ 320.0 , 180.0 , - 300.0 ]);
s . execute ( "layer.transform" , json! ({ "layers" : [ a ], "op" : "fit" })). unwrap ();
assert_eq! ( pos ( & s , a ), [ 320.0 , 180.0 , - 300.0 ]);
let b = solid ( & mut s , "#00ff00" );
s . execute ( "prop.set" , json! ({ "layer" : b , "path" : "transform/position" , "value" : [ 10 , 20 ]})). unwrap ();
s . execute ( "prop.separateDimensions" , json! ({ "layer" : b , "value" : true })). unwrap ();
s . execute ( "layer.transform" , json! ({ "layers" : [ b ], "op" : "center" })). unwrap ();
assert_eq! ( pos ( & s , b )[ .. 2 ], [ 320.0 , 180.0 ]);
s . execute ( "layer.transform" , json! ({ "layers" : [ b ], "op" : "reset" })). unwrap ();
assert_eq! ( pos ( & s , b )[ .. 2 ], [ 320.0 , 180.0 ]);
// Center Anchor Point moves separated X / Y Position too, so the layer stays put.
s . execute ( "prop.set" , json! ({ "layer" : b , "path" : "transform/anchor" , "value" : [ 0 , 0 ]})). unwrap ();
s . execute ( "prop.set" , json! ({ "layer" : b , "path" : "transform/positionX" , "value" : 100 })). unwrap ();
s . execute ( "prop.set" , json! ({ "layer" : b , "path" : "transform/positionY" , "value" : 50 })). unwrap ();
s . execute ( "layer.centerAnchor" , json! ({ "layers" : [ b ]})). unwrap ();
assert_eq! ( pos ( & s , b )[ .. 2 ], [ 200.0 , 100.0 ], "the 200× 100 solid's centre" );
}
#[test]
fn duplicated_and_pasted_layers_keep_their_links () {
let mut s = comp ();
let parent = solid ( & mut s , "#ff0000" );
let matte = solid ( & mut s , "#ffffff" );
let child = solid ( & mut s , "#00ff00" );
s . execute ( "layer.setParent" , json! ({ "layers" : [ child ], "parent" : parent })). unwrap ();
s . execute ( "layer.setTrackMatte" , json! ({ "layer" : child , "matte" : matte , "kind" : "alpha" })). unwrap ();
let m = layer ( & s , child ). track_matte . unwrap (). layer ;
assert_eq! ( m . 0 , matte );
// Duplicating the child alone keeps the original parent and matte.
let d = s . execute ( "edit.duplicate" , json! ({ "layers" : [ child ]})). unwrap ()[ 0 ]. as_u64 (). unwrap ();
assert_eq! (( layer ( & s , d ). parent . map ( | l | l . 0 ), layer ( & s , d ). track_matte . map ( | t | t . layer )), ( Some ( parent ), Some ( m )));
// Duplicating parent and child together: the copy follows the copied parent.
let r = s . execute ( "edit.duplicate" , json! ({ "layers" : [ parent , child ]})). unwrap ();
let ( p2 , c2 ) = ( r [ 0 ]. as_u64 (). unwrap (), r [ 1 ]. as_u64 (). unwrap ());
assert_eq! ( layer ( & s , c2 ). parent . map ( | l | l . 0 ), Some ( p2 ));
// Copy / paste in the same composition keeps the links; in another one they are dropped.
s . execute ( "layer.select" , json! ({ "layers" : [ child ]})). unwrap ();
s . execute ( "edit.copy" , json! ({})). unwrap ();
let pasted = s . execute ( "edit.paste" , json! ({})). unwrap ()[ 0 ]. as_u64 (). unwrap ();
assert_eq! ( layer ( & s , pasted ). parent . map ( | l | l . 0 ), Some ( parent ));
assert_eq! ( layer ( & s , pasted ). track_matte . map ( | t | t . layer ), Some ( m ));
s . execute ( "comp.new" , json! ({ "name" : "Other" , "width" : 64 , "height" : 64 })). unwrap ();
let other = s . execute ( "edit.paste" , json! ({})). unwrap ()[ 0 ]. as_u64 (). unwrap ();
assert_eq! (( layer ( & s , other ). parent , layer ( & s , other ). track_matte ), ( None , None ));
}
2026-10-04 23:48:54 +07:00
#[test]
fn precompose_takes_the_compositions_settings () {
let mut s = Session ::default ();
s . execute (
"comp.new" ,
json! ({ "name" : "Main" , "width" : 640 , "height" : 360 , "pixelAspect" : 2.0 , "shutterAngle" : 90 , "motionBlurSamples" : 8 , "renderer" : "advanced3D" , "background" : [ 0.2 , 0.3 , 0.4 ]}),
)
. unwrap ();
let a = solid ( & mut s , "#ff0000" );
let r = s . execute ( "layer.precompose" , json! ({ "layers" : [ a ], "name" : "Inner" })). unwrap ();
let inner = s . project . comp ( effectcraft_project ::ItemId ( r [ "comp" ]. as_u64 (). unwrap ())). unwrap ();
assert_eq! (( inner . pixel_aspect , inner . shutter_angle , inner . motion_blur_samples ), ( 2.0 , 90.0 , 8 ));
assert_eq! (( inner . renderer , inner . background ), ( effectcraft_project ::Renderer ::Advanced3D , [ 0.2 , 0.3 , 0.4 ]));
}
#[test]
fn new_comp_from_selection_is_one_undo_step_with_the_dialog_options () {
let mut s = Session ::default ();
let still = | s : & mut Session , name : & str , w : u32 , par : f64 | {
let f = effectcraft_project ::Footage {
kind : effectcraft_project ::FootageKind ::Still ,
width : w ,
height : 100 ,
pixel_aspect : par ,
has_video : true ,
.. Default ::default ()
};
std ::sync ::Arc ::make_mut ( & mut s . project ). add_item ( name , effectcraft_color ::Label ::None , None , ItemKind ::Footage ( f ))
};
let a = still ( & mut s , "a.png" , 200 , 1.0 );
let b = still ( & mut s , "b.png" , 300 , 2.0 );
s . state . project_selection = vec! [ a , b ];
// Multiple compositions (the default): one per item, its size and pixel aspect; one undo step.
let steps = s . history . undo . len ();
let r = s . execute ( "file.newCompFromSelection" , json! ({ "duration" : 4 })). unwrap ();
let comps : Vec < u64 > = r [ "comps" ]. as_array (). unwrap (). iter (). map ( | v | v . as_u64 (). unwrap ()). collect ();
assert_eq! ( comps . len (), 2 );
let cb = s . project . comp ( effectcraft_project ::ItemId ( comps [ 1 ])). unwrap ();
assert_eq! (( cb . width , cb . pixel_aspect , cb . duration . seconds ()), ( 300 , 2.0 , 4.0 ));
assert_eq! ( s . history . undo . len (), steps + 1 );
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( s . project . comps (). count (), 0 );
// One composition holding both, sized like the second, sequenced with a 1 s overlap, queued.
s . state . project_selection = vec! [ a , b ];
let r = s
. execute (
"file.newCompFromSelection" ,
json! ({ "single" : true , "dimensionsFrom" : 1 , "duration" : 3 , "sequence" : true , "overlap" : true , "overlapDuration" : 1 , "addToRenderQueue" : true }),
)
. unwrap ();
let c = s . project . comp ( effectcraft_project ::ItemId ( r [ "comps" ][ 0 ]. as_u64 (). unwrap ())). unwrap ();
assert_eq! (( c . width , c . pixel_aspect , c . duration . seconds ()), ( 300 , 2.0 , 5.0 ));
let names : Vec <& str > = c . layers . iter (). map ( | l | l . name . as_str ()). collect ();
assert_eq! ( names , [ "a.png" , "b.png" ], "first selected on top" );
// Stills have no rate: the comp is 29.97 fps and the second layer starts on the frame nearest 2 s.
assert_eq! ( c . layers [ 0 ]. in_point . seconds (), 0.0 );
assert! (( c . layers [ 1 ]. in_point . seconds () - 2.0 ). abs () < 1.0 / 29.97 , "{}" , c . layers [ 1 ]. in_point . seconds ());
assert_eq! ( s . project . render_queue . len (), 1 );
assert_eq! ( s . history . undo . len (), steps + 1 );
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert! ( s . project . render_queue . is_empty () && s . project . comps (). count () == 0 );
s . state . project_selection = vec! [ a , b ];
assert! ( s . execute ( "file.newCompFromSelection" , json! ({ "single" : true , "dimensionsFrom" : 2 })). is_err ());
}
2026-10-05 00:08:07 +07:00
#[test]
fn project_files_keep_their_format_warn_about_newer_versions_and_never_save_unreadable () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
let path = tmp ( "Safe.ecproj" );
s . execute ( "file.saveAs" , json! ({ "path" : path })). unwrap ();
let saved = std ::fs ::read_to_string ( & path ). unwrap ();
assert_eq! ( effectcraft_project ::saved_by ( & saved ). as_deref (), Some ( effectcraft_project ::APP_VERSION ));
// Save a Copy and Increment and Save keep an XML project XML.
let copy = tmp ( "Copy.ecprojx" );
s . execute ( "file.saveCopy" , json! ({ "path" : copy })). unwrap ();
assert! ( std ::fs ::read_to_string ( & copy ). unwrap (). starts_with ( "<?xml" ));
s . execute ( "file.saveAs" , json! ({ "path" : tmp ( "Xml.ecprojx" )})). unwrap ();
let r = s . execute ( "file.incrementAndSave" , json! ({})). unwrap ();
let inc = r [ "path" ]. as_str (). unwrap (). to_string ();
assert! ( inc . ends_with ( "Xml 2.ecprojx" ), "{inc}" );
assert! ( std ::fs ::read_to_string ( & inc ). unwrap (). starts_with ( "<?xml" ));
let r = s . execute ( "file.open" , json! ({ "path" : inc })). unwrap ();
assert_eq! ( r [ "savedBy" ], json! ( effectcraft_project ::APP_VERSION ));
// A project from a newer version opens with a warning.
let newer = tmp ( "Newer.ecproj" );
std ::fs ::write ( & newer , saved . replacen ( effectcraft_project ::APP_VERSION , "999.0.0" , 1 )). unwrap ();
s . drain_events ();
let r = s . execute ( "file.open" , json! ({ "path" : newer })). unwrap ();
assert_eq! ( r [ "savedBy" ], json! ( "999.0.0" ));
let warned = s . drain_events (). into_iter (). any ( | e | matches! ( e , Event ::Toast { message , .. } if message . contains ( "newer than this version" )));
assert! ( warned );
// A value a project file can't hold: Save fails and the file on disk is left as it was.
s . execute ( "file.open" , json! ({ "path" : path })). unwrap ();
let cid = s . state . active_comp . unwrap ();
std ::sync ::Arc ::make_mut ( & mut s . project )
. comp_mut ( cid )
. unwrap ()
. layer_mut ( effectcraft_project ::LayerId ( a ))
. unwrap ()
. props
. prop_mut ( "transform/opacity" )
. unwrap ()
. value = KV ::Scalar ( f64 ::NAN );
let e = s . execute ( "file.save" , json! ({})). unwrap_err (). to_string ();
assert! ( e . contains ( "can't be saved" ), "{e}" );
assert_eq! ( std ::fs ::read_to_string ( & path ). unwrap (), saved );
// Not a project: a clear message.
let junk = tmp ( "Junk.ecproj" );
std ::fs ::write ( & junk , "{ not json" ). unwrap ();
let e = s . execute ( "file.open" , json! ({ "path" : junk })). unwrap_err (). to_string ();
assert! ( e . contains ( "is not a project EffectCraft can open" ), "{e}" );
}
2026-10-05 01:33:14 +07:00
#[test]
fn comp_settings_preserve_frame_rate_and_resolution () {
let mut s = comp ();
let info = s . execute ( "comp.info" , json! ({})). unwrap ();
assert_eq! (( info [ "preserveFrameRate" ]. clone (), info [ "preserveResolution" ]. clone ()), ( json! ( false ), json! ( false )));
s . execute_checked ( "comp.settings" , json! ({ "preserveFrameRate" : true , "preserveResolution" : true })). unwrap ();
let info = s . execute ( "comp.info" , json! ({})). unwrap ();
assert_eq! (( info [ "preserveFrameRate" ]. clone (), info [ "preserveResolution" ]. clone ()), ( json! ( true ), json! ( true )));
// Pre-compose keeps them; one undo step clears them.
let a = solid ( & mut s , "#ff0000" );
let r = s . execute ( "layer.precompose" , json! ({ "layers" : [ a ], "name" : "Inner" })). unwrap ();
let inner = s . project . comp ( effectcraft_project ::ItemId ( r [ "comp" ]. as_u64 (). unwrap ())). unwrap ();
assert! ( inner . preserve_frame_rate && inner . preserve_resolution );
// Undo Pre-compose and the solid; then one more step undoes the settings.
s . execute ( "edit.undo" , json! ({})). unwrap ();
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert! ( s . active_comp (). unwrap (). preserve_frame_rate );
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert! ( ! s . active_comp (). unwrap (). preserve_frame_rate && ! s . active_comp (). unwrap (). preserve_resolution );
}
2026-10-05 06:30:46 +07:00
#[test]
fn new_comp_from_selection_survives_hostile_sequence_numbers () {
let mut s = Session ::default ();
let still = | s : & mut Session , name : & str | {
let f = effectcraft_project ::Footage {
kind : effectcraft_project ::FootageKind ::Still ,
width : 64 ,
height : 64 ,
pixel_aspect : 1.0 ,
has_video : true ,
.. Default ::default ()
};
std ::sync ::Arc ::make_mut ( & mut s . project ). add_item ( name , effectcraft_color ::Label ::None , None , ItemKind ::Footage ( f ))
};
let a = still ( & mut s , "a.png" );
let b = still ( & mut s , "b.png" );
let c = still ( & mut s , "c.png" );
for overlap in [ json! ( 1e30 ), json! ( - 5 ), json! ( f64 ::MAX )] {
s . state . project_selection = vec! [ a , b , c ];
// A huge overlap overflowed the duration arithmetic (a panic with overflow checks, a
// wrapped, too long comp without them).
let r = s
. execute ( "file.newCompFromSelection" , json! ({ "single" : true , "sequence" : true , "overlap" : true , "overlapDuration" : overlap , "duration" : 2 }))
. unwrap ();
let c = s . project . comp ( effectcraft_project ::ItemId ( r [ "comps" ][ 0 ]. as_u64 (). unwrap ())). unwrap ();
assert! ( c . duration . seconds () <= 6.0 && c . duration > effectcraft_time ::Tick ::ZERO , "{overlap}: {}" , c . duration . seconds ());
}
s . state . project_selection = vec! [ a , b ];
assert! ( s . execute ( "file.newCompFromSelection" , json! ({ "single" : true , "dimensionsFrom" : 99 })). is_err ());
}
2026-10-05 07:40:42 +07:00
fn key_times ( s : & Session , l : u64 ) -> Vec < f64 > {
layer ( s , l ). props . prop ( "transform/opacity" ). unwrap (). keys . iter (). map ( | k | ( k . time . seconds () * 30.0 ). round () / 30.0 ). collect ()
}
fn opacity_keys ( s : & mut Session , l : u64 , times : & [ f64 ]) {
for ( i , t ) in times . iter (). enumerate () {
s . execute ( "prop.addKey" , json! ({ "layer" : l , "path" : "transform/opacity" , "time" : t , "value" : i as f64 * 10.0 })). unwrap ();
}
}
#[test]
fn dragging_a_key_past_another_keeps_it () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
opacity_keys ( & mut s , a , & [ 1.0 , 2.0 ]);
s . execute ( "keys.select" , json! ({ "keys" : [{ "layer" : a , "path" : "transform/opacity" , "time" : 1.0 }]})). unwrap ();
// One drag, frame by frame, from 1 s over the 2 s key to 3 s.
for _ in 0 .. 60 {
s . execute ( "keys.move" , json! ({ "delta" : 1.0 / 30.0 , "merge" : "key-drag" })). unwrap ();
}
assert_eq! ( key_times ( & s , a ), vec! [ 2.0 , 3.0 ], "the 2 s key passed over is still there" );
// Dropped exactly on a key: it replaces it, as in After Effects.
s . history . merge_key = None ;
s . execute ( "keys.move" , json! ({ "delta" : - 1.0 , "merge" : "key-drag-2" })). unwrap ();
assert_eq! ( key_times ( & s , a ), vec! [ 2.0 ]);
// The whole drag was one undo step.
s . execute ( "edit.undo" , json! ({})). unwrap ();
s . execute ( "edit.undo" , json! ({})). unwrap ();
assert_eq! ( key_times ( & s , a ), vec! [ 1.0 , 2.0 ]);
}
#[test]
fn keys_of_a_stretched_layer_move_with_the_pointer () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
opacity_keys ( & mut s , a , & [ 0.0 , 1.0 ]);
s . execute_checked ( "layer.timeStretch" , json! ({ "layers" : [ a ], "percent" : 200 })). unwrap ();
assert_eq! ( layer ( & s , a ). stretch , 200.0 );
let comp_time = | s : & Session , i : usize | {
let l = layer ( s , a );
l . comp_time ( l . props . prop ( "transform/opacity" ). unwrap (). keys [ i ]. time ). seconds ()
};
let before = comp_time ( & s , 1 );
s . execute ( "keys.select" , json! ({ "keys" : [{ "layer" : a , "path" : "transform/opacity" , "time" : 1.0 }]})). unwrap ();
s . execute ( "keys.move" , json! ({ "delta" : 0.5 })). unwrap ();
assert! (( comp_time ( & s , 1 ) - ( before + 0.5 )). abs () < 1.0 / 30.0 , "{} → {}" , before , comp_time ( & s , 1 ));
s . execute ( "keys.nudge" , json! ({ "frames" : 3 })). unwrap ();
assert! (( comp_time ( & s , 1 ) - ( before + 0.6 )). abs () < 1.0 / 60.0 , "three comp frames" );
}
#[test]
fn key_selection_toggles_and_skips_locked_layers_and_hold_restores_bezier () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
opacity_keys ( & mut s , a , & [ 0.0 , 1.0 ]);
let k = | t : f64 | json! ({ "layer" : a , "path" : "transform/opacity" , "time" : t });
s . execute ( "keys.select" , json! ({ "keys" : [ k ( 0.0 )]})). unwrap ();
s . execute ( "keys.select" , json! ({ "keys" : [ k ( 1.0 )], "toggle" : true })). unwrap ();
assert_eq! ( s . state . selected_keys . len (), 2 );
s . execute ( "keys.select" , json! ({ "keys" : [ k ( 0.0 )], "toggle" : true })). unwrap ();
assert_eq! ( s . state . selected_keys . len (), 1 , "toggled out" );
// Hold off returns an eased key to Bezier.
s . execute ( "keys.easyEase" , json! ({})). unwrap ();
s . execute ( "keys.toggleHold" , json! ({})). unwrap ();
s . execute ( "keys.toggleHold" , json! ({})). unwrap ();
let kf = layer ( & s , a ). props . prop ( "transform/opacity" ). unwrap (). keys [ 1 ]. clone ();
assert_eq! ( kf . out_interp , effectcraft_keyframe ::Interp ::Bezier );
// Locked: its keys can't be selected.
s . execute ( "layer.setSwitch" , json! ({ "layers" : [ a ], "switch" : "lock" , "value" : true })). unwrap ();
s . execute ( "keys.select" , json! ({ "keys" : [ k ( 0.0 )]})). unwrap ();
assert! ( s . state . selected_keys . is_empty ());
s . execute ( "keys.selectAll" , json! ({ "layers" : [ a ]})). unwrap ();
assert! ( s . state . selected_keys . is_empty ());
}
2026-10-05 07:52:20 +07:00
#[test]
fn transform_drags_apply_their_whole_offset_to_the_keys_they_started_with () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
opacity_keys ( & mut s , a , & [ 0.0 , 1.0 , 2.0 ]);
s . execute ( "keys.selectAll" , json! ({ "layers" : [ a ]})). unwrap ();
// Squeezed onto one frame on the way, then back: the three keys survive.
for k in [ 0.5 , 0.01 , 0.0001 , 1.0 ] {
s . execute ( "keys.transform" , json! ({ "timeScale" : k , "timeAnchor" : 0.0 , "merge" : "box" , "fromStart" : true })). unwrap ();
}
assert_eq! ( key_times ( & s , a ), vec! [ 0.0 , 1.0 , 2.0 ]);
// A slow move in tiny steps still arrives (each step is the whole offset).
s . history . merge_key = None ;
for i in 1 ..= 30 {
s . execute ( "keys.transform" , json! ({ "timeOffset" : i as f64 * 0.1 / 30.0 , "merge" : "move" , "fromStart" : true })). unwrap ();
}
assert_eq! ( key_times ( & s , a ), vec! [ 0.1 , 1.1 , 2.1 ]);
}
2026-10-05 07:58:03 +07:00
#[test]
fn select_equal_previous_and_following_keyframes () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
for ( t , v ) in [( 0.0 , 20.0 ), ( 1.0 , 50.0 ), ( 2.0 , 20.0 ), ( 3.0 , 70.0 )] {
s . execute ( "prop.addKey" , json! ({ "layer" : a , "path" : "transform/opacity" , "time" : t , "value" : v })). unwrap ();
}
let pick = | s : & mut Session , t : f64 | s . execute ( "keys.select" , json! ({ "keys" : [{ "layer" : a , "path" : "transform/opacity" , "time" : t }]})). unwrap ();
let times = | s : & Session | {
let mut v : Vec < f64 > = s . state . selected_keys . iter (). map ( | k | k . time . seconds ()). collect ();
v . sort_by ( f64 ::total_cmp );
v
};
pick ( & mut s , 0.0 );
s . execute ( "keys.selectEqual" , json! ({})). unwrap ();
assert_eq! ( times ( & s ), vec! [ 0.0 , 2.0 ]);
pick ( & mut s , 2.0 );
s . execute ( "keys.selectPrevious" , json! ({})). unwrap ();
assert_eq! ( times ( & s ), vec! [ 0.0 , 1.0 , 2.0 ]);
pick ( & mut s , 1.0 );
s . execute ( "keys.selectFollowing" , json! ({})). unwrap ();
assert_eq! ( times ( & s ), vec! [ 1.0 , 2.0 , 3.0 ]);
}
2026-10-05 08:02:16 +07:00
#[test]
fn keys_from_several_layers_paste_in_order_and_paste_reversed_respects_stretch () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
let b = solid ( & mut s , "#00ff00" );
opacity_keys ( & mut s , a , & [ 0.0 , 1.0 ]);
s . execute ( "prop.addKey" , json! ({ "layer" : b , "path" : "transform/opacity" , "time" : 0.0 , "value" : 77 })). unwrap ();
let c = solid ( & mut s , "#0000ff" );
let d = solid ( & mut s , "#ffffff" );
// Copy A's and B's Opacity keys, paste onto C and D: A → C, B → D (in order).
s . execute ( "keys.selectAll" , json! ({ "layers" : [ a , b ]})). unwrap ();
s . execute ( "keys.copy" , json! ({})). unwrap ();
s . execute ( "time.set" , json! ({ "time" : 2.0 })). unwrap ();
s . execute ( "layer.select" , json! ({ "layers" : [ c , d ]})). unwrap ();
s . execute ( "keys.paste" , json! ({})). unwrap ();
assert_eq! ( key_times ( & s , c ), vec! [ 2.0 , 3.0 ], "A's two keys" );
assert_eq! ( key_times ( & s , d ), vec! [ 2.0 ], "B's one key" );
// Paste Reversed onto a layer stretched to 200 %: the reversed keys land 2 s apart there too.
let e = solid ( & mut s , "#808080" );
s . execute_checked ( "layer.timeStretch" , json! ({ "layers" : [ e ], "percent" : 200 })). unwrap ();
s . execute ( "keys.selectAll" , json! ({ "layers" : [ a ]})). unwrap ();
s . execute ( "keys.copy" , json! ({})). unwrap ();
s . execute ( "time.set" , json! ({ "time" : 0.0 })). unwrap ();
s . execute ( "layer.select" , json! ({ "layers" : [ e ]})). unwrap ();
s . execute ( "edit.pasteReversedKeyframes" , json! ({})). unwrap ();
let pr = layer ( & s , e ). props . prop ( "transform/opacity" ). unwrap (). clone ();
let l = layer ( & s , e );
let ct : Vec < f64 > = pr . keys . iter (). map ( | k | l . comp_time ( k . time ). seconds ()). collect ();
let vals : Vec < f64 > = pr . keys . iter (). map ( | k | k . value . as_f64 ()). collect ();
assert! ( ct . len () == 2 && ( ct [ 1 ] - ct [ 0 ] - 1.0 ). abs () < 1e-6 , "keys 1 s apart in comp time: {ct:?}" );
assert_eq! ( vals , vec! [ 10.0 , 0.0 ], "reversed" );
}
2026-10-05 08:05:03 +07:00
#[test]
fn j_and_k_stop_at_keys_markers_and_the_work_area () {
let mut s = comp ();
let a = solid ( & mut s , "#ff0000" );
opacity_keys ( & mut s , a , & [ 2.0 ]);
s . execute ( "comp.workArea" , json! ({ "start" : 1.0 , "end" : 3.0 })). unwrap ();
s . execute ( "layer.select" , json! ({ "layers" : [ a ]})). unwrap ();
let mut stops = vec! [];
for _ in 0 .. 4 {
s . execute ( "time.nextKey" , json! ({})). unwrap ();
stops . push (( s . time (). seconds () * 30.0 ). round () / 30.0 );
}
let last = ( 3.0 * 30.0 - 1.0 ) / 30.0 ;
assert_eq! ( stops , vec! [ 1.0 , 2.0 , ( last * 30.0 f64 ). round () / 30.0 , ( last * 30.0 f64 ). round () / 30.0 ]);
}