Files
vectorcraft/crates/engine/src/tests/script_run.rs
T
dotCooCoo f05d481247 Control bar: Select Similar Objects selects by the attribute its menu keeps
With something selected, the Control bar shows a Select Similar Objects
button and, beside it, the Select Similar Options menu. The button
selects the objects like the first selected one by the attribute kept
for the session; a menu item selects by its attribute and keeps it,
and the kept item is checked. The items are All, Fill Color, Fill &
Stroke, Stroke Color, Stroke Weight, Opacity, Blending Mode,
Appearance, Graphic Style, Shape and Symbol Instance.

- select.similar {by?} runs the select.same command of that name, or
  for "all" matches fill and stroke colors, stroke weight, opacity and
  blending mode together. An unknown by is an error that keeps the
  selection and the kept attribute. The journal records the attribute
  used, so a recorded action repeats it, and a failed script or plug-in
  call puts the kept attribute back.
- The button and menu belong to the Object Options group and sit at
  the right end of the bar, after the X, Y, W and H fields. They take
  only the room the other controls leave, so the bar leaves them out
  before any other control.
- The Paragraph tests' control_bar_node looks for a label before a
  value, so a link's text run listed first no longer stands in for
  the link.

Docs: docs/mcp.md, docs/target-app-parity.md.
2026-11-14 18:41:14 -08:00

1086 lines
47 KiB
Rust

//! `script.run` and `script.stop`: one transaction per run, the rollback after a throw, a limit, a
//! stop or a panic, the mutation lease between slices, ids, growth and what a run reports.
use std::cell::Cell;
use serde_json::{Value, json};
use crate::script::{PANIC_IN_SLICE, TEST_GROWTH, TEST_RESULT_BYTES};
use crate::*;
fn rect(x: i64) -> Value {
json!({"x": x, "y": 0, "width": 10, "height": 10})
}
/// Two open documents, each with one rectangle, the second one active.
fn two_docs() -> Session {
let mut s = Session::new();
for x in [0, 50] {
s.execute("file.new", &json!({})).unwrap();
s.execute("shape.rectangle", &rect(x)).unwrap();
}
s
}
/// What a rollback has to put back.
fn state(s: &Session) -> Value {
let docs: Vec<Value> = s
.documents()
.iter()
.map(|d| {
json!({
"uid": d.uid,
"art": format!("{:?}", d.doc.layers),
"selection": d.selection.objects.iter().map(|i| i.0).collect::<Vec<_>>(),
"undo": d.history.undo.iter().map(|e| e.label.clone()).collect::<Vec<_>>(),
"redo": d.history.redo.len(),
"path": d.path,
"dirty": d.is_dirty(),
})
})
.collect();
json!({"docs": docs, "active": s.active().map(|d| d.uid), "journal": s.journal.len(), "paint": format!("{:?}", s.paint)})
}
fn run(s: &mut Session, source: &str) -> Result<Value> {
s.execute("script.run", &json!({"source": source, "name": "t.js"}))
}
fn objects(s: &Session, doc: usize) -> usize {
s.documents()[doc].doc.layers.iter().map(|l| l.children().map_or(0, Vec::len)).sum()
}
/// A framed run of `source`, one slice in.
fn paused(s: &mut Session, source: &str) {
s.script_frames = true;
assert_eq!(run(s, source).unwrap()["running"], true);
assert!(s.script_pump().is_none());
assert!(s.script_running());
}
fn two_rect_script() -> String {
"vc.run('shape.rectangle', {x:100,y:0,width:5,height:5});\
vc.run('shape.rectangle', {x:110,y:0,width:5,height:5});\
vc.run('document.activate', {index:0});\
vc.run('shape.rectangle', {x:120,y:0,width:5,height:5});\
vc.run('document.activate', {index:1});"
.to_string()
}
#[test]
fn a_run_is_one_undo_step_in_each_document_it_changed() {
let mut s = two_docs();
let before = state(&s);
let r = run(&mut s, &two_rect_script()).unwrap();
assert_eq!(r["ok"], true);
assert_eq!((objects(&s, 0), objects(&s, 1)), (2, 3));
assert_eq!(s.documents()[0].history.undo.last().unwrap().label, "Run Script");
assert_eq!(s.documents()[1].history.undo.last().unwrap().label, "Run Script");
assert_eq!(s.documents()[1].history.undo.len(), before["docs"][1]["undo"].as_array().unwrap().len() + 1);
let after = format!("{:?}", s.documents()[1].doc.layers);
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(objects(&s, 1), 1);
assert_eq!(format!("{:?}", s.documents()[1].doc.layers), before["docs"][1]["art"].as_str().unwrap());
assert_eq!(s.documents()[1].selection.objects.len(), before["docs"][1]["selection"].as_array().unwrap().len());
s.execute("edit.redo", &json!({})).unwrap();
assert_eq!(format!("{:?}", s.documents()[1].doc.layers), after);
}
#[test]
fn a_run_that_changes_nothing_leaves_no_step_no_mark_and_no_journal_entry() {
for source in ["", "var a = 1 + 2;", "vc.log(vc.document); vc.commands.length;"] {
let mut s = two_docs();
s.execute("document.save", &json!({"path": std::env::temp_dir().join(format!("vc-noop-{}.svg", std::process::id())).to_string_lossy()}))
.unwrap();
let before = state(&s);
let revisions = |s: &Session| s.documents().iter().map(|d| d.revision).collect::<Vec<_>>();
let revisions_before = revisions(&s);
let r = run(&mut s, source).unwrap();
assert_eq!(r["changed"], json!([]), "{source}");
assert_eq!(state(&s), before, "{source}");
assert_eq!(revisions(&s), revisions_before, "{source}");
}
}
#[test]
fn a_caught_command_failure_leaves_nothing_behind_and_the_script_goes_on() {
let mut s = two_docs();
let source = "var m = '';\
try { vc.run('command.batch', {commands: [\
{command:'shape.rectangle', params:{x:1,y:1,width:1,height:1}},\
{command:'no.such', params:{}}]}); } catch (e) { m = e.message; }\
try { vc.run('shape.rectangle', {x:'bad'}); } catch (e) { m += '|' + e.name; }\
vc.log(m); vc.run('shape.rectangle', {x:200,y:0,width:5,height:5});";
let r = run(&mut s, source).unwrap();
assert_eq!(objects(&s, 1), 2, "{r}");
assert!(r["log"][0].as_str().unwrap().contains("|Error"), "{r}");
}
#[test]
fn a_failure_puts_back_every_document_and_the_session() {
enum How {
Throw,
Fuel,
Stop,
Panic,
}
for how in [How::Throw, How::Fuel, How::Stop, How::Panic] {
let mut s = two_docs();
let before = state(&s);
let edits = two_rect_script();
let r = match how {
How::Throw => run(&mut s, &format!("{edits} throw new Error('boom');")),
How::Fuel => s.execute("script.run", &json!({"source": format!("{edits} while (true) {{}}"), "maxFuel": 2_000_000})),
How::Stop => {
paused(&mut s, &format!("{edits} while (true) {{}}"));
assert_eq!(s.execute("script.stop", &json!({})).unwrap()["stopped"], true);
assert_eq!(s.execute("script.stop", &json!({})).unwrap()["stopped"], true);
s.script_pump().unwrap()
}
How::Panic => {
paused(&mut s, &format!("{edits} while (true) {{}}"));
PANIC_IN_SLICE.with(|p| p.set(true));
let r = s.script_pump().unwrap();
PANIC_IN_SLICE.with(|p| p.set(false));
r
}
};
assert!(r.is_err());
assert_eq!(state(&s), before);
assert!(!s.script_running());
s.script_frames = false;
assert_eq!(run(&mut s, "1").unwrap()["ok"], true, "a later run starts");
}
}
#[test]
fn a_stop_with_no_run_reports_it() {
assert_eq!(Session::new().execute("script.stop", &json!({})).unwrap()["stopped"], false);
}
#[test]
fn an_error_names_the_script_its_place_and_kind() {
let mut s = two_docs();
let e = run(&mut s, "var a;\n throw new TypeError('no');").unwrap_err().to_string();
assert_eq!(e, "t.js: line 2, column 3: TypeError: no (thrown)");
let e = run(&mut s, "var = 1;").unwrap_err().to_string();
assert!(e.starts_with("t.js: line 1,") && e.ends_with("(syntax)"), "{e}");
assert!(run(&mut s, "app.activeDocument;").unwrap_err().to_string().contains("`vc`"));
assert!(run(&mut s, "#targetengine 9x\n1").unwrap_err().to_string().contains("#targetengine needs a name of letters, digits and _"));
assert_eq!(s.script_report().unwrap()["line"], 1);
}
/// An error raised where the run has no place for it, such as in code `eval` compiled, is named
/// with the script and its kind alone, with one colon after the script's name.
#[test]
fn an_error_without_a_place_names_the_script_and_kind() {
let mut s = two_docs();
let e = run(&mut s, "eval(\"throw new TypeError('no')\");").unwrap_err().to_string();
assert_eq!(s.script_report().unwrap()["line"], 0);
assert_eq!(e, "t.js: TypeError: no (thrown)");
}
#[test]
fn bad_parameters_are_refused_before_anything_runs() {
let mut s = two_docs();
let before = state(&s);
let mut deep = json!(1);
for _ in 0..100 {
deep = json!([deep]);
}
for p in [
json!({}),
json!({"source": "1", "args": {"a": deep}}),
json!({"path": "a", "source": "b"}),
json!({"path": ""}),
json!({"path": 1}),
json!({"source": "1", "nope": 1}),
json!({"source": "1", "args": []}),
json!({"source": "1", "args": {"a": "x".repeat(1 << 20)}}),
json!({"source": "1", "answers": {"a": 1}}),
json!({"source": "1", "answers": 1}),
json!({"source": "1", "maxFuel": 0}),
json!({"source": "1", "maxFuel": -1}),
json!({"source": "1", "maxFuel": 1.5}),
json!({"source": "1", "maxFuel": "9"}),
json!({"source": "1", "maxFuel": 100_000_000_001u64}),
] {
assert!(matches!(s.execute("script.run", &p), Err(EngineError::BadParams { .. })), "{p}");
}
assert_eq!(state(&s), before);
}
#[test]
fn files_are_checked_before_they_are_read() {
let dir = std::env::temp_dir().join(format!("vc-script-run-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let write = |name: &str, bytes: &[u8]| {
let p = dir.join(name);
std::fs::write(&p, bytes).unwrap();
p.to_string_lossy().into_owned()
};
let mut s = two_docs();
let path = |p: &str| json!({"path": p});
let ok = write("Bézier (1) & co.js", b"\xef\xbb\xbfvc.log(1);\r\nvc.log(2);\r\n");
let r = s.execute("script.run", &path(&ok)).unwrap();
assert_eq!((r["log"].clone(), r["name"].as_str()), (json!([1, 2]), Some("Bézier (1) & co.js")));
let invalid = write("a.js", b"var a = '\xff';");
assert!(s.execute("script.run", &path(&invalid)).unwrap_err().to_string().contains("UTF-8"));
let huge = write("huge.js", &vec![b' '; script::MAX_SOURCE_BYTES + 1]);
assert!(s.execute("script.run", &path(&huge)).unwrap_err().to_string().contains("too large"));
let compiled = write("b.jsxbin", b"@JSXBIN@ES@2.0@");
assert!(s.execute("script.run", &path(&compiled)).unwrap_err().to_string().contains("compiled"));
let renamed = write("c.js", b"@JSXBIN@ES@2.0@");
assert!(s.execute("script.run", &path(&renamed)).unwrap_err().to_string().contains("compiled"));
assert!(s.execute("script.run", &path(&dir.to_string_lossy())).is_err());
let huge_source = " ".repeat(script::MAX_SOURCE_BYTES + 1);
assert!(run(&mut s, &huge_source).unwrap_err().to_string().contains("too large"));
let other = write("notes.txt", b"vc.log(1);");
assert!(matches!(s.execute("script.run", &path(&other)), Err(EngineError::BadParams { .. })), "a text file that is not a script");
let upper = write("UP.JSX", b"vc.log(3);");
assert_eq!(s.execute("script.run", &path(&upper)).unwrap()["log"], json!([3]));
std::fs::create_dir_all(dir.join("folder.js")).unwrap();
assert!(s.execute("script.run", &path(&dir.join("folder.js").to_string_lossy())).is_err());
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_failed_batch_puts_back_the_session_and_names_a_file_it_wrote() {
let path = std::env::temp_dir().join(format!("vc-script-batch-{}.svg", std::process::id()));
let _ = std::fs::remove_file(&path);
let p = path.to_string_lossy().into_owned();
let mut s = two_docs();
let source = format!(
"try {{ vc.run('command.batch', {{commands: [\
{{command: 'view.guides.lock', params: {{locked: true}}}},\
{{command: 'document.export', params: {{path: {p:?}, format: 'svg'}}}},\
{{command: 'no.such', params: {{}}}}]}}); }} catch (e) {{ vc.log(e.name); }}"
);
let r = run(&mut s, &source).unwrap();
assert_eq!(r["log"], json!(["Error"]), "{r}");
assert!(!s.guides_locked(), "the failed batch's Lock Guides does not stay");
assert!(path.exists());
assert_eq!(r["written"], json!([p]), "{r}");
let _ = std::fs::remove_file(&path);
}
#[test]
fn an_export_that_fails_names_no_file() {
let path = std::env::temp_dir().join(format!("vc-script-no-folder-{}", std::process::id())).join("out.svg");
let p = path.to_string_lossy().into_owned();
let mut s = two_docs();
let source = format!("try {{ vc.run('document.export', {{path: {p:?}, format: 'svg'}}); }} catch (e) {{ vc.log(e.name); }}");
let r = run(&mut s, &source).unwrap();
assert_eq!(r["log"], json!(["Error"]), "{r}");
assert!(!path.exists());
assert_eq!(r["written"], json!([]), "{r}");
}
#[test]
fn a_failed_run_puts_back_the_choices_its_commands_made() {
let mut s = two_docs();
let before = s.global_edit_options.clone();
let source = "vc.run('select.globalEditOptions', {appearance: !vc.run('select.globalEditOptions', {}).appearance}); throw new Error('x');";
assert!(run(&mut s, source).is_err());
assert_eq!(s.global_edit_options, before);
let source = "try { vc.run('command.batch', {commands: [\
{command: 'select.globalEditOptions', params: {size: true}},\
{command: 'no.such', params: {}}]}); } catch (e) {}";
run(&mut s, source).unwrap();
assert_eq!(s.global_edit_options, before, "the failed command's choice went back");
let source = "vc.run('shape.rectangle', {x: 0, y: 0, width: 10, height: 10}); \
if (vc.run('select.similar', {by: 'opacity'}).by !== 'opacity') throw new Error('not run'); throw new Error('x');";
assert!(matches!(run(&mut s, source), Err(e) if !format!("{e:?}").contains("not run")));
assert_eq!(s.select_similar, "all", "the Select Similar Objects attribute went back");
assert!(!s.caps_lock);
assert!(run(&mut s, "vc.run('view.capsLock', {on: true}); throw new Error('x');").is_err());
assert!(!s.caps_lock, "the Caps Lock state went back");
run(&mut s, "vc.run('view.capsLock', {on: true});").unwrap();
assert!(s.caps_lock, "a finished run keeps it");
}
#[test]
fn a_failed_run_puts_back_the_preferences_its_commands_changed() {
let mut s = two_docs();
let basic = s.prefs.new_art_basic;
assert!(run(&mut s, &format!("vc.run('appearance.setNewArtBasic', {{on: {}}}); throw new Error('x');", !basic)).is_err());
assert_eq!(s.prefs.new_art_basic, basic);
}
#[test]
fn a_finished_run_keeps_its_preferences_and_the_ones_the_app_changed_meanwhile() {
let mut s = two_docs();
let (basic, increment) = (s.prefs.new_art_basic, s.prefs.keyboard_increment);
paused(&mut s, &format!("vc.run('appearance.setNewArtBasic', {{on: {}}}); for (var i = 0; i < 2000000; i++) {{}}", !basic));
assert_eq!(s.prefs.new_art_basic, basic, "between slices the app sees the preferences before the run");
s.prefs.keyboard_increment = increment + 1.0;
s.execute("view.capsLock", &json!({"on": true})).unwrap();
while s.script_pump().is_none() {}
assert_eq!((s.prefs.new_art_basic, s.prefs.keyboard_increment), (!basic, increment + 1.0));
assert!(s.caps_lock, "the Caps Lock state the app reported during the run stays");
}
#[test]
fn a_script_cannot_load_the_place_cursor() {
let mut s = two_docs();
let e = run(&mut s, "vc.run('file.place.queue', {paths: []});").unwrap_err().to_string();
assert!(e.contains("a script cannot run `file.place.queue`"), "{e}");
let listed = run(&mut s, "vc.log(vc.commands.some(function (c) { return c.id === 'file.place.queue'; }));").unwrap();
assert_eq!(listed["log"], json!([false]), "{listed}");
}
#[test]
fn a_command_whose_result_cannot_cross_is_put_back() {
TEST_RESULT_BYTES.with(|b| b.set(Some(1)));
let mut s = two_docs();
let r = run(&mut s, "try { vc.run('shape.rectangle', {x:1,y:1,width:1,height:1}); } catch (e) { vc.log(e.name); }");
TEST_RESULT_BYTES.with(|b| b.set(None));
let r = r.unwrap();
assert_eq!(r["log"], json!(["RangeError"]), "{r}");
assert_eq!(r["changed"], json!([]), "{r}");
assert_eq!((objects(&s, 0), objects(&s, 1)), (1, 1));
}
#[test]
fn an_abandoned_run_reports_the_files_it_wrote() {
let path = std::env::temp_dir().join(format!("vc-script-abandon-{}.svg", std::process::id()));
let _ = std::fs::remove_file(&path);
let p = path.to_string_lossy().into_owned();
let mut s = two_docs();
paused(&mut s, &format!("vc.run('document.export', {{path: {p:?}, format: 'svg'}}); while (true) {{}}"));
assert!(path.exists(), "the first slice exported");
assert!(s.script_abandon());
let report = s.script_report().unwrap();
assert_eq!((report["kind"].as_str(), report["written"].clone()), (Some("stopped"), json!([p])), "{report}");
assert!(s.script_failure_text().unwrap().contains(&p));
let _ = std::fs::remove_file(&path);
}
#[test]
fn a_run_that_only_closes_a_document_keeps_its_journal_entry() {
let mut s = two_docs();
let journal = s.journal.len();
let r = run(&mut s, "vc.run('file.close', {index: 1});").unwrap();
assert_eq!(r["changed"], json!([]), "{r}");
assert_eq!(s.documents().len(), 1);
assert_eq!(s.journal.len(), journal + 1);
assert_eq!(s.journal.iter().last().unwrap().0, "file.close");
}
#[test]
fn a_command_that_can_fail_after_copying_has_the_clipboard_put_back() {
let mut s = two_docs();
let keep_clipboard = |s: &mut Session, id: &str| {
let save = script::Savepoint::take(s, id);
s.clipboard.source_artboard = Some(Default::default());
save.restore(s);
};
keep_clipboard(&mut s, "edit.cut");
assert_eq!(s.clipboard.source_artboard, None, "put back");
s.clipboard.source_artboard = Some(Default::default());
keep_clipboard(&mut s, "shape.rectangle");
assert!(s.clipboard.source_artboard.is_some(), "only those commands pay for a copy of the clipboard");
}
#[test]
fn a_commands_savepoint_copies_the_same_number_of_undo_steps_however_long_the_runs_history() {
let copied = |n: usize| {
let mut s = two_docs();
crate::history::ENTRY_CLONES.with(|c| c.set(0));
let r = run(&mut s, &format!("for (var i = 0; i < {n}; i++) vc.run('shape.rectangle', {{x:i,y:1,width:1,height:1}});")).unwrap();
assert_eq!(r["ok"], true);
assert_eq!(objects(&s, 1), n + 1);
crate::history::ENTRY_CLONES.with(Cell::get)
};
let (few, many) = (copied(20), copied(200));
// Each command copies at most its document's newest step, whatever the history holds.
assert!(many <= 200 + few, "{few} steps copied for 20 commands, {many} for 200");
}
#[test]
fn undo_redo_and_a_long_redo_stack_copy_the_same_number_of_steps_per_command() {
let copied = |n: usize| {
let mut s = two_docs();
crate::history::ENTRY_CLONES.with(|c| c.set(0));
let source = format!(
"for (var i = 0; i < {n}; i++) vc.run('shape.rectangle', {{x:i,y:1,width:1,height:1}});\
for (var i = 0; i < {n}; i++) vc.run('edit.undo');\
for (var i = 0; i < {n}; i++) vc.run('select.none');\
for (var i = 0; i < {n}; i++) vc.run('edit.redo');"
);
let r = run(&mut s, &source).unwrap();
assert_eq!(r["ok"], true, "{r}");
assert_eq!(objects(&s, 1), n + 1);
crate::history::ENTRY_CLONES.with(Cell::get)
};
let (few, many) = (copied(20), copied(200));
// Ten times the commands copy about ten times the steps: each command copies its document's
// newest undo and redo steps, whatever the stacks hold.
assert!(many <= 12 * few, "{few} steps copied for 80 commands, {many} for 800");
}
#[test]
fn a_failed_command_gives_back_the_redo_steps_and_an_undo_it_made() {
let mut s = two_docs();
for x in 1..=3 {
s.execute("shape.rectangle", &rect(x)).unwrap();
}
for _ in 0..2 {
s.execute("edit.undo", &json!({})).unwrap();
}
let before = state(&s);
let save = script::Savepoint::take(&mut s, "shape.rectangle");
s.execute("shape.rectangle", &rect(9)).unwrap();
assert_eq!(s.documents()[1].history.redo.len(), 0);
assert!(save.restore(&mut s), "the redo steps the new step cleared are put back");
assert_eq!(state(&s), before);
let save = script::Savepoint::take(&mut s, "edit.undo");
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.redo", &json!({})).unwrap();
s.execute("edit.redo", &json!({})).unwrap();
assert!(save.restore(&mut s));
assert_eq!(state(&s), before);
for _ in 0..2 {
s.execute("edit.redo", &json!({})).unwrap();
}
assert_eq!(objects(&s, 1), 4);
}
#[test]
fn a_failed_command_at_the_history_limit_keeps_the_oldest_step() {
let mut s = two_docs();
s.docs[1].history.limit = 5;
let before = state(&s);
for x in 1..=5 {
s.execute("shape.rectangle", &rect(x)).unwrap();
}
let save = script::Savepoint::take(&mut s, "shape.rectangle");
s.execute("shape.rectangle", &rect(9)).unwrap();
assert!(save.restore(&mut s), "the step the limit would have let go is put back");
assert_eq!(objects(&s, 1), 6);
for _ in 0..5 {
s.execute("edit.undo", &json!({})).unwrap();
}
assert_eq!(state(&s)["docs"][1]["art"], before["docs"][1]["art"]);
}
#[test]
fn a_snapshot_too_large_to_cross_throws_instead_of_reading_as_no_document() {
let mut s = two_docs();
s.docs[1].path = Some("x".repeat(17 << 20));
let r = run(&mut s, "var m = ''; try { vc.document; m = 'read'; } catch (e) { m = e.name + ': ' + e.message; } vc.log(m);").unwrap();
let m = r["log"][0].as_str().unwrap();
assert!(m.starts_with("RangeError: vc.document.") && m.ends_with("is too large for a script"), "{m}");
}
#[test]
fn recovery_copies_made_between_slices_hold_the_art_before_the_run() {
let store = std::sync::Arc::new(cmd::recovery::MemoryStore::default());
let mut s = two_docs();
s.recovery.set_store(store.clone());
paused(&mut s, &format!("{} while (true) {{}}", two_rect_script()));
cmd::recovery::save_copies(&mut s).unwrap();
s.script_abandon();
drop(s);
let mut s = Session::new();
s.recovery.set_store(store);
let r = s.execute("file.recovery.restore", &json!({})).unwrap();
assert_eq!(r["restored"].as_array().map(Vec::len), Some(2), "{r}");
assert_eq!((objects(&s, 0), objects(&s, 1)), (1, 1), "the copies hold the art from before the run");
}
#[test]
fn values_that_cannot_cross_are_named_and_shared_ones_can() {
let mut s = two_docs();
let cases = [
("var a = {}; a.a = a; vc.run('shape.rectangle', a);", "RangeError|TypeError"),
("var a = {}, c = a; for (var i = 0; i < 100; i++) { c.n = {}; c = c.n; } vc.run('shape.rectangle', a);", "RangeError|TypeError"),
("vc.run('shape.rectangle', {x: 1/0});", "RangeError|TypeError"),
("vc.run('shape.rectangle', {x: function () {}});", "RangeError|TypeError"),
("vc.run('shape.rectangle', 7);", "TypeError"),
("vc.run(7);", "TypeError"),
];
for (source, kinds) in cases {
let e = run(&mut s, source).unwrap_err().to_string();
assert!(kinds.split('|').any(|k| e.contains(k)), "{source}: {e}");
}
let r = run(&mut s, "var p = {w: 5}; vc.log({a: p, b: p}); var l = ''; for (var i = 0; i < 20; i++) l += 'xxxxxxxxxx'; vc.log(l);").unwrap();
assert_eq!(r["log"][0], json!({"a": {"w": 5}, "b": {"w": 5}}));
assert_eq!(r["log"][1].as_str().unwrap().len(), 200);
}
#[test]
fn commands_outside_the_documents_are_refused_in_a_batch_too() {
let mut s = two_docs();
for source in [
"vc.run('prefs.set', {key: 'a', value: 1});",
"vc.run('script.run', {source: '1'});",
"vc.run('script.stop');",
"vc.run('edit.undoGroup.begin', {});",
"vc.run('view.proofColors', {on: true});",
"vc.run('view.proofSetup', {});",
"vc.run('view.overprintPreview', {on: true});",
"vc.run('view.separationsPreview', {});",
"vc.run('command.batch', {commands: [{command: 'prefs.reset', params: {}}]});",
] {
let e = run(&mut s, source).unwrap_err().to_string();
assert!(e.contains("cannot run"), "{source}: {e}");
}
let r = run(&mut s, "var c = vc.commands; var n = 0; for (var i = 0; i < c.length; i++) if (c[i].id.indexOf('prefs.') === 0) n++; vc.log(n); vc.log(c.length > 100);").unwrap();
assert_eq!(r["log"], json!([0, true]));
}
#[test]
fn a_script_cannot_clear_the_undo_steps_from_before_its_run() {
let mut s = two_docs();
let steps = s.documents()[1].history.undo.len();
let source = "vc.run('shape.rectangle', {x:9,y:9,width:1,height:1});\
var m = ''; try { vc.run('edit.clearHistory'); } catch (e) { m = e.message; } vc.log(m);";
let r = run(&mut s, source).unwrap();
assert_eq!(r["log"], json!(["a script cannot run `edit.clearHistory`"]), "{r}");
assert_eq!(s.documents()[1].history.undo.len(), steps + 1);
}
#[test]
fn the_vc_object_reads_the_active_document_and_cannot_be_changed() {
let mut s = two_docs();
let r = s
.execute(
"script.run",
&json!({"name": "x", "args": {"n": 2}, "source": "vc.args.n = 9; vc.api.version = 'x'; vc.log(vc.args.n); vc.log(vc.api.version); vc.log(vc.api.has('run')); vc.log(vc.api.has('nope')); vc.log(vc.document.artboards); vc.log(typeof vc.document.path);"}),
)
.unwrap();
assert_eq!(r["log"], json!([2, "1.0", true, false, 1, "object"]));
let mut empty = Session::new();
assert_eq!(run(&mut empty, "vc.log(vc.document === null);").unwrap()["log"], json!([true]));
assert!(run(&mut empty, "vc.run('shape.rectangle', {x:0,y:0,width:1,height:1});").unwrap_err().to_string().contains("Error"));
}
#[test]
fn the_log_is_bounded_and_a_script_can_catch_that() {
let mut s = two_docs();
let r = run(
&mut s,
"var n = 0; try { while (true) { vc.log(n); n++; } } catch (e) { vc.run('document.inspect', {}); throw new Error(e.name + ' at ' + n); }",
);
let e = r.unwrap_err().to_string();
assert!(e.contains(&format!("RangeError at {}", script::MAX_LOG_LINES)), "{e}");
}
#[test]
fn between_slices_every_change_is_refused_and_readers_see_the_committed_art() {
let mut s = two_docs();
let before = state(&s);
paused(&mut s, &format!("{} while (true) {{}}", two_rect_script()));
assert_eq!(state(&s), before);
for (id, p) in [
("shape.rectangle", rect(1)),
("clipboard.importSvg", json!({})),
("clipboard.importImage", json!({})),
("clipboard.importText", json!({})),
("clipboard.importPdf", json!({})),
("clipboard.importEmf", json!({})),
("clipboard.importEps", json!({})),
("edit.undo", json!({})),
("file.new", json!({})),
("file.close", json!({})),
("file.revert", json!({})),
("file.recovery.restore", json!({})),
("action.batch", json!({})),
("command.batch", json!({"commands": []})),
("effect.apply", json!({})),
("script.run", json!({"source": "1"})),
] {
assert!(matches!(s.execute(id, &p), Err(EngineError::Busy)), "{id}");
}
assert!(matches!(s.begin_interaction("x"), Err(EngineError::Busy)));
assert!(matches!(s.edit("x", |_, _| Ok(())), Err(EngineError::Busy)));
assert!(matches!(s.preview("shape.rectangle", &rect(1)), Err(EngineError::Busy)));
let press = tools::PointerEvent {
kind: tools::PointerKind::Down,
..serde_json::from_value(json!({"kind": "move", "pos": {"x": 0.0, "y": 0.0}})).unwrap()
};
assert!(matches!(s.pointer(&press, ViewInfo::default()), Err(EngineError::Busy)));
let inspected = s.execute("document.inspect", &json!({})).unwrap();
assert_eq!(inspected["layers"][0]["children"].as_array().map(Vec::len), Some(1), "{inspected}");
assert_eq!(state(&s), before, "the refused commands changed nothing");
s.script_abandon();
assert_eq!(state(&s), before);
assert!(s.execute("shape.rectangle", &rect(1)).unwrap()["id"].is_u64());
}
#[test]
fn a_document_closed_or_opened_in_a_run_follows_the_run() {
let closing = "vc.run('file.close', {index: 0}); vc.run('file.new', {}); vc.run('shape.rectangle', {x:1,y:1,width:1,height:1});";
let mut s = two_docs();
let before = state(&s);
assert!(run(&mut s, &format!("{closing} throw new Error('x');")).is_err());
assert_eq!(state(&s), before);
let first = s.documents()[0].uid;
run(&mut s, closing).unwrap();
assert_eq!(s.documents().len(), 2);
assert!(s.documents().iter().all(|d| d.uid != first));
assert_eq!(s.documents()[1].history.undo.len(), 0, "a document the script made starts with no undo steps");
}
#[test]
fn undo_in_a_run_reaches_only_the_runs_own_steps_and_old_ids_stay_dead() {
let mut s = two_docs();
let history = s.documents()[1].history.undo.len();
let source = "var p = vc.run('shape.rectangle', {x:1,y:1,width:1,height:1}).id;\
vc.run('edit.undo');\
var q = vc.run('shape.rectangle', {x:2,y:2,width:1,height:1}).id;\
var why = '';\
try { vc.run('edit.clear', {ids: [p]}); } catch (e) { why = e.message; }\
vc.run('edit.undo');\
try { vc.run('edit.undo'); why += '|undid a step from before the run'; } catch (e) { why += '|stopped'; }\
vc.log({same: p === q, why: why});\
vc.run('shape.rectangle', {x:3,y:3,width:1,height:1});";
let r = run(&mut s, source).unwrap();
assert_eq!(r["log"][0]["same"], false, "{r}");
let why = r["log"][0]["why"].as_str().unwrap();
assert!(why.ends_with("|stopped") && why.len() > "|stopped".len(), "{why}");
assert_eq!(objects(&s, 1), 2);
assert_eq!(s.documents()[1].history.undo.len(), history + 1);
}
#[test]
fn a_string_over_the_crossing_limit_does_not_cross() {
let limits = vectorcraft_js::DataLimits { bytes: 20, ..vectorcraft_js::DataLimits::default() };
assert!(script::to_data(&json!("four"), &limits, 0, &mut (0, 0)).is_ok());
assert_eq!(script::to_data(&json!("fives"), &limits, 0, &mut (0, 0)), Err(String::new()));
}
#[test]
fn a_result_too_large_to_cross_names_its_place() {
let limits = vectorcraft_js::DataLimits { bytes: 90, ..vectorcraft_js::DataLimits::default() };
let v = json!({"a": [1, {"name": "x".repeat(40)}]});
assert_eq!(script::to_data(&v, &limits, 0, &mut (0, 0)), Err(".a[1].name".to_string()));
}
#[test]
fn ids_given_out_in_an_abandoned_run_are_not_given_out_again() {
let mut s = two_docs();
let before = s.active().unwrap().doc.peek_next_id();
paused(&mut s, &format!("{} while (true) {{}}", two_rect_script()));
assert!(s.script_abandon());
assert!(s.active().unwrap().doc.peek_next_id() > before);
}
#[test]
fn ids_given_out_in_a_failed_run_are_not_given_out_again() {
let mut s = two_docs();
let e =
run(&mut s, "var p = vc.run('shape.rectangle', {x:1,y:1,width:1,height:1}).id; throw new Error('id=' + p + ';');").unwrap_err().to_string();
let used: u64 = e.split("id=").nth(1).unwrap().split(';').next().unwrap().parse().unwrap();
let dirty = s.documents()[1].is_dirty();
let id = s.execute("shape.rectangle", &rect(3)).unwrap()["id"].as_u64().unwrap();
assert!(id > used, "{id} after {used}");
assert!(dirty);
}
#[test]
fn a_rollback_keeps_the_history_after_an_undo_in_the_run() {
let mut s = two_docs();
let before = state(&s);
let source = "vc.run('shape.rectangle', {x:1,y:1,width:1,height:1}); vc.run('edit.undo'); throw new Error('x');";
assert!(run(&mut s, source).is_err());
assert_eq!(state(&s), before);
}
#[test]
fn a_batch_joins_the_runs_one_step() {
let mut s = two_docs();
let undo = s.documents()[1].history.undo.len();
let source = "vc.run('command.batch', {commands: [\
{command:'shape.rectangle', params:{x:1,y:1,width:1,height:1}},\
{command:'shape.rectangle', params:{x:2,y:2,width:1,height:1}}]});";
run(&mut s, source).unwrap();
assert_eq!(s.documents()[1].history.undo.len(), undo + 1);
assert_eq!(objects(&s, 1), 3);
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(objects(&s, 1), 1);
}
#[test]
fn a_run_with_nobody_to_ask_ends_at_its_growth_allowance() {
TEST_GROWTH.with(|g| g.set(Some(20)));
let mut s = two_docs();
let before = state(&s);
let source = "try { while (true) vc.run('shape.rectangle', {x:1,y:1,width:1,height:1}); } catch (e) { vc.run('shape.rectangle', {x:2,y:1,width:1,height:1}); }";
let e = run(&mut s, source).unwrap_err().to_string();
TEST_GROWTH.with(|g| g.set(None));
assert!(e.contains("objects and data"), "{e}");
assert_eq!(state(&s), before);
}
#[test]
fn a_document_a_run_opens_counts_toward_its_growth_allowance() {
TEST_GROWTH.with(|g| g.set(Some(20)));
let rects: String = (0..30).map(|i| format!(r#"<rect x="{i}" y="0" width="1" height="1"/>"#)).collect();
let svg = format!(r#"<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">{rects}</svg>"#);
let data = vectorcraft_format::base64_encode(svg.as_bytes());
let mut s = two_docs();
let before = state(&s);
let source = format!("try {{ vc.run('document.open', {{name: 'a.svg', dataBase64: '{data}'}}); }} catch (e) {{}}");
let e = run(&mut s, &source).unwrap_err().to_string();
assert!(e.contains("objects and data"), "{e}");
assert_eq!(state(&s), before);
// A document whose art is all in a symbol counts it too.
let mut maker = Session::new();
maker.execute("file.new", &json!({})).unwrap();
for x in 0..30 {
maker.execute("shape.rectangle", &rect(x)).unwrap();
}
maker.execute("select.all", &json!({})).unwrap();
let instance = maker.execute("symbol.new", &json!({"name": "Many"})).unwrap()["id"].as_u64().unwrap();
maker.execute("edit.clear", &json!({"ids": [instance]})).unwrap();
assert_eq!(objects(&maker, 0), 0);
let data = maker.execute("document.serialize", &json!({})).unwrap()["dataBase64"].as_str().unwrap().to_string();
let source = format!("vc.run('document.open', {{name: 'b.vectorcraft', dataBase64: '{data}'}});");
let e = run(&mut s, &source).unwrap_err().to_string();
TEST_GROWTH.with(|g| g.set(None));
assert!(e.contains("objects and data"), "{e}");
assert_eq!(state(&s), before);
}
#[test]
fn graph_design_art_counts_toward_the_growth_allowance() {
TEST_GROWTH.with(|g| g.set(Some(20)));
let mut s = two_docs();
for x in 0..30 {
s.execute("shape.rectangle", &rect(x)).unwrap();
}
let before = state(&s);
let designs = |s: &Session| s.documents().iter().map(|d| d.doc.graph_designs.len()).collect::<Vec<_>>();
let designs_before = designs(&s);
// A design saved from the selection in an open document.
let e = run(&mut s, "vc.run('select.all'); vc.run('graph.design', {new: 'Many'});").unwrap_err().to_string();
assert!(e.contains("objects and data"), "{e}");
assert_eq!(state(&s), before);
assert_eq!(designs(&s), designs_before);
// A document a run opens whose art is all in a graph design.
let mut maker = Session::new();
maker.execute("file.new", &json!({})).unwrap();
let ids: Vec<u64> = (0..30).map(|x| maker.execute("shape.rectangle", &rect(x)).unwrap()["id"].as_u64().unwrap()).collect();
maker.execute("select.all", &json!({})).unwrap();
maker.execute("graph.design", &json!({"new": "Many"})).unwrap();
maker.execute("edit.clear", &json!({"ids": ids})).unwrap();
assert_eq!(objects(&maker, 0), 0);
assert_eq!(maker.documents()[0].doc.graph_designs[0].art.count_with_masks(), 31);
let data = maker.execute("document.serialize", &json!({})).unwrap()["dataBase64"].as_str().unwrap().to_string();
let source = format!("vc.run('document.open', {{name: 'g.vectorcraft', dataBase64: '{data}'}});");
let e = run(&mut s, &source).unwrap_err().to_string();
TEST_GROWTH.with(|g| g.set(None));
assert!(e.contains("objects and data"), "{e}");
assert_eq!(state(&s), before);
}
/// Drops `v` one level at a time.
fn drop_flat(v: Value) {
let mut stack = vec![v];
while let Some(mut v) = stack.pop() {
match &mut v {
Value::Object(o) => stack.extend(std::mem::take(o).into_iter().map(|(_, x)| x)),
Value::Array(a) => stack.append(a),
_ => {}
}
}
}
#[test]
fn args_nested_ten_thousand_deep_in_a_script_throw_a_range_error_with_their_place() {
let mut s = two_docs();
let before = state(&s);
let source = "var v = 1; for (var i = 0; i < 10000; i++) v = {a: v}; var m = 'none'; \
try { vc.run('script.run', {source: '', args: v}); } catch (e) { m = e.name + '|' + e.message; } vc.log(m);";
let r = run(&mut s, source).unwrap();
let m = r["log"][0].as_str().unwrap_or_default();
assert!(m.starts_with("RangeError|") && m.contains(".args.a.a.a") && m.contains("nested too deep"), "{r}");
assert_eq!(state(&s), before);
}
#[test]
fn args_nested_ten_thousand_deep_from_a_caller_are_refused_with_their_place() {
let mut s = two_docs();
let before = state(&s);
// Built by moving each level in: `json!` would copy the value through `to_value`, one call per level.
let wrap = |key: &str, v: Value| Value::Object(std::iter::once((key.to_string(), v)).collect());
let mut deep = json!(1);
for _ in 0..10_000 {
deep = wrap("a", deep);
}
let mut params = wrap("args", wrap("b", deep));
params["source"] = json!("");
let e = s.execute("script.run", &params).unwrap_err().to_string();
drop_flat(params);
assert!(e.contains("`args.b.a.a.a") && e.contains("nested more than 64 levels deep"), "{e}");
assert_eq!(state(&s), before);
}
#[test]
fn a_person_can_let_a_growing_run_go_on_or_stop_it() {
TEST_GROWTH.with(|g| g.set(Some(20)));
let run_to_the_question = |s: &mut Session| {
s.script_frames = true;
run(s, "for (var i = 0; i < 25; i++) vc.run('shape.rectangle', {x:i,y:1,width:1,height:1});").unwrap();
let slices = Cell::new(0);
while !s.script_waiting() {
assert!(s.script_pump().is_none());
slices.set(slices.get() + 1);
assert!(slices.get() < 1_000);
}
// Waiting takes no fuel, however often the frame comes round.
assert!(s.script_pump().is_none());
};
let mut s = two_docs();
run_to_the_question(&mut s);
s.script_continue();
assert!(!s.script_waiting());
let done = loop {
if let Some(r) = s.script_pump() {
break r;
}
};
assert_eq!(done.unwrap()["ok"], true);
assert_eq!(objects(&s, 1), 26);
let mut s = two_docs();
let before = state(&s);
run_to_the_question(&mut s);
assert_eq!(s.execute("script.stop", &json!({})).unwrap()["stopped"], true);
assert!(!s.script_waiting());
assert!(s.script_pump().unwrap().is_err());
TEST_GROWTH.with(|g| g.set(None));
assert_eq!(state(&s), before);
}
#[test]
fn a_run_waiting_to_grow_stops_at_the_next_slice_once_its_work_is_canceled() {
TEST_GROWTH.with(|g| g.set(Some(20)));
let mut s = two_docs();
let before = state(&s);
s.script_frames = true;
run(&mut s, "for (var i = 0; i < 25; i++) vc.run('shape.rectangle', {x:i,y:1,width:1,height:1});").unwrap();
let token = crate::cancel::CancelToken::new();
for _ in 0..1_000 {
if s.script_waiting() {
break;
}
assert!(crate::cancel::scope(&token, None, || s.script_pump()).is_none());
}
assert!(s.script_waiting());
token.cancel();
let ended = crate::cancel::scope(&token, None, || s.script_pump());
TEST_GROWTH.with(|g| g.set(None));
assert!(ended.expect("the run goes on waiting for Continue").is_err());
assert_eq!(s.script_report().unwrap()["kind"], "stopped");
assert!(!s.script_running());
assert_eq!(state(&s), before);
}
#[test]
fn a_file_saved_before_a_failure_stays_written_and_is_named() {
let path = std::env::temp_dir().join(format!("vc-script-save-{}.svg", std::process::id()));
let _ = std::fs::remove_file(&path);
let p = path.to_string_lossy().into_owned();
let mut s = two_docs();
let before = state(&s);
let source =
format!("vc.run('file.saveAs', {{path: {p:?}}}); vc.run('shape.rectangle', {{x:1,y:1,width:1,height:1}}); throw new Error('later');");
let e = run(&mut s, &source).unwrap_err().to_string();
assert!(path.exists());
assert!(e.contains(&p), "{e}");
assert_eq!(s.script_report().unwrap()["written"], json!([p]));
assert_eq!(state(&s), before, "the document does not keep the new path");
let _ = std::fs::remove_file(&path);
}
/// A run in the app's frames keeps the file-access scope its `script.run` came in, whatever scope
/// the frames that advance it run in.
#[test]
fn a_framed_run_keeps_the_file_access_scope_it_started_in() {
let dir = std::env::temp_dir().join(format!("vc-script-scope-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let (allowed, outside) = (dir.join("allowed"), dir.join("outside"));
std::fs::create_dir_all(&allowed).unwrap();
std::fs::create_dir_all(&outside).unwrap();
let roots = crate::file_access::AutomationRoots::new(&[&allowed], &[&allowed]).unwrap().unwrap();
let export = |target: &std::path::Path| {
let p = target.to_string_lossy().into_owned();
format!("try {{ vc.run('document.export', {{path: {p:?}, format: 'svg'}}); vc.log('ok'); }} catch (e) {{ vc.log(e.name); }}")
};
let finish = |s: &mut Session| {
loop {
if let Some(r) = s.script_pump() {
return r;
}
}
};
let mut s = two_docs();
s.script_frames = true;
let confined_target = outside.join("confined.svg");
let started = crate::file_access::confine(Some(&roots), || run(&mut s, &export(&confined_target))).unwrap();
assert_eq!(started["running"], true);
let r = crate::file_access::unconfined(|| finish(&mut s)).unwrap();
assert_eq!(r["log"], json!(["Error"]), "a confined caller's run stays confined: {r}");
assert!(!confined_target.exists());
let user_target = outside.join("user.svg");
let started = crate::file_access::unconfined(|| run(&mut s, &export(&user_target))).unwrap();
assert_eq!(started["running"], true);
let r = crate::file_access::confine(Some(&roots), || finish(&mut s)).unwrap();
assert_eq!(r["log"], json!(["ok"]), "a run the person started is not confined by a later caller: {r}");
assert!(user_target.exists());
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_committed_run_exports_what_it_drew() {
let path = std::env::temp_dir().join(format!("vc-script-export-{}.svg", std::process::id()));
let _ = std::fs::remove_file(&path);
let p = path.to_string_lossy().into_owned();
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
let source = "for (var i = 0; i < 7; i++) vc.run('shape.rectangle', {x:i*20,y:5,width:10,height:10});";
run(&mut s, source).unwrap();
s.execute("document.save", &json!({"path": p})).unwrap();
let svg = std::fs::read_to_string(&path).unwrap();
assert_eq!(svg.matches("<rect").count() + svg.matches("<path").count(), 7, "{svg}");
let inspected = s.execute("document.inspect", &json!({})).unwrap();
assert_eq!(inspected["layers"][0]["children"].as_array().map(Vec::len), Some(7));
let _ = std::fs::remove_file(&path);
}
#[test]
fn a_run_needing_a_recovery_copy_it_cannot_write_does_not_start() {
let mut s = two_docs();
s.script_copy_first = true;
let before = state(&s);
let e = run(&mut s, "vc.run('shape.rectangle', {x:1,y:1,width:1,height:1});").unwrap_err().to_string();
assert!(e.contains("recovery copy"), "{e}");
assert_eq!(state(&s), before);
assert!(!s.script_running());
}
#[test]
fn a_run_does_not_start_while_a_complex_document_goes_without_a_copy() {
let store = std::sync::Arc::new(cmd::recovery::MemoryStore::default());
let mut s = Session::new();
s.recovery.set_store(store);
s.script_copy_first = true;
let mut d = vectorcraft_doc::Document::new(1000.0, 1000.0);
let layer = d.layers[0].id;
for i in 0..cmd::recovery::COMPLEX_OBJECTS {
let id = d.alloc_id();
let r = vectorcraft_geom::Rect::new((i % 200) as f64, (i / 200) as f64, (i % 200) as f64 + 1.0, (i / 200) as f64 + 1.0);
let n = vectorcraft_doc::Node::path(id, vectorcraft_geom::shapes::rectangle(r), vectorcraft_doc::Appearance::default_art());
d.insert(Some(layer), i, n).unwrap();
}
s.add_document(d, None);
s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 5, "height": 5})).unwrap();
s.prefs.recovery_off_for_complex = true;
let e = run(&mut s, "1").unwrap_err().to_string();
assert!(e.contains("recovery copy"), "{e}");
assert!(!s.script_running());
s.prefs.recovery_off_for_complex = false;
assert_eq!(run(&mut s, "1").unwrap()["ok"], true);
}
#[test]
fn an_open_undo_group_stops_a_run_from_starting() {
let mut s = two_docs();
s.execute("edit.undoGroup.begin", &json!({})).unwrap();
assert!(run(&mut s, "1").unwrap_err().to_string().contains("undo group"));
s.execute("edit.undoGroup.end", &json!({})).unwrap();
assert_eq!(run(&mut s, "1").unwrap()["ok"], true);
}
#[test]
fn a_cancel_from_the_caller_stops_a_headless_run() {
let mut s = two_docs();
let before = state(&s);
let stop = s.script_interrupt();
stop.set();
assert!(s.execute("script.run", &json!({"source": "1", "maxFuel": 10_000})).is_ok(), "a run clears a flag left from before");
assert!(!stop.is_set());
assert_eq!(state(&s), before);
}
/// Script text: pieces that change documents, throw or loop, mixed with arbitrary text.
fn source_text() -> impl proptest::strategy::Strategy<Value = String> {
use proptest::prelude::*;
let piece = prop_oneof![
Just("vc.run('shape.rectangle', {x:1,y:1,width:5,height:5});".to_string()),
Just("vc.run('select.all'); vc.run('edit.clear');".to_string()),
Just("vc.run('file.new', {});".to_string()),
Just("vc.run('document.activate', {index:0});".to_string()),
Just("vc.run('no.such');".to_string()),
Just("vc.log(vc.document);".to_string()),
Just("throw new Error('x');".to_string()),
Just("vc.run('shape.rectangle', {x:2,y:2,width:5,height:5}); throw new Error('y');".to_string()),
Just("while (true) {}".to_string()),
Just("var o = {}; o.o = o; vc.run('shape.rectangle', o);".to_string()),
Just("{".to_string()),
Just("try {".to_string()),
Just("} catch (e) {}".to_string()),
Just("\n#include \"x.jsxinc\"\n".to_string()),
Just("\n//@include 'x\n".to_string()),
Just("\n#includepath \";;..;\"\n".to_string()),
Just("\n#script \"\"\n".to_string()),
Just("\n#target\n".to_string()),
Just("\n#strict on\n".to_string()),
Just("\n#\u{0}\n".to_string()),
Just("try { $.evalFile('x.jsx', NaN); } catch (e) {}".to_string()),
"\n#[a-z]{0,12}[ -~]{0,20}\n",
"[ -~]{0,30}",
"\\PC{0,10}",
];
proptest::collection::vec(piece, 0..12).prop_map(|p| p.concat())
}
/// Every field of each open document but its next id, and the rest of what a rollback puts back.
/// A failed run raises the next id past the ids it gave out, which [`next_ids`] reads.
fn saved(s: &Session) -> (Value, Vec<String>) {
let docs = s
.documents()
.iter()
.map(|d| {
let mut doc = (*d.doc).clone();
doc.raise_next_id(1 << 50);
format!("{doc:?}")
})
.collect();
(state(s), docs)
}
fn next_ids(s: &Session) -> Vec<u64> {
s.documents().iter().map(|d| d.doc.peek_next_id()).collect()
}
proptest::proptest! {
#![proptest_config(proptest::prelude::ProptestConfig::with_cases(48))]
/// Any script text ends with a report or a script error, and a run that fails leaves every
/// document as it was.
#[test]
fn any_source_ends_with_a_report_or_a_script_error(source in source_text()) {
let mut s = two_docs();
let (before, ids) = (saved(&s), next_ids(&s));
match s.execute("script.run", &json!({"source": source, "maxFuel": 200_000})) {
Ok(r) => proptest::prop_assert_eq!(&r["ok"], &json!(true), "{}", r),
Err(e) => {
proptest::prop_assert!(matches!(e, EngineError::Other(_)), "{:?}", e);
let kind = s.script_report.as_ref().map(|r| r["kind"].clone());
proptest::prop_assert!(kind.as_ref().is_some_and(|k| k != "internal"), "{:?}: {}", kind, e);
proptest::prop_assert_eq!(saved(&s), before);
proptest::prop_assert!(next_ids(&s).iter().zip(&ids).all(|(after, was)| after >= was), "{:?} after {:?}", next_ids(&s), ids);
}
}
}
}