@owenlamont/ryl 0.4.1

package/tests/yamllint_compat_document_start.rs

@@ -0,0 +1,136 @@
+use std::fs;
+
+use tempfile::tempdir;
+
+#[path = "common/compat.rs"]
+mod compat;
+
+use compat::{
+    SCENARIOS, build_ryl_command, build_yamllint_command, capture_with_env,
+    ensure_yamllint_installed,
+};
+
+#[test]
+fn document_start_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let missing = dir.path().join("missing.yaml");
+    fs::write(&missing, "foo: bar\n").unwrap();
+
+    let explicit = dir.path().join("explicit.yaml");
+    fs::write(&explicit, "---\nfoo: bar\n").unwrap();
+
+    let require_cfg = dir.path().join("require.yml");
+    fs::write(
+        &require_cfg,
+        "rules:\n  document-start:\n    level: error\n    present: true\n",
+    )
+    .unwrap();
+
+    let forbid_cfg = dir.path().join("forbid.yml");
+    fs::write(
+        &forbid_cfg,
+        "rules:\n  document-start:\n    level: error\n    present: false\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        let mut ryl_require = build_ryl_command(exe, scenario.ryl_format);
+        ryl_require.arg("-c").arg(&require_cfg).arg(&missing);
+        let (ryl_req_code, ryl_req_msg) = capture_with_env(ryl_require, scenario.envs);
+
+        let mut yam_require = build_yamllint_command(scenario.yam_format);
+        yam_require.arg("-c").arg(&require_cfg).arg(&missing);
+        let (yam_req_code, yam_req_msg) = capture_with_env(yam_require, scenario.envs);
+
+        assert_eq!(ryl_req_code, 1, "ryl require exit ({})", scenario.label);
+        assert_eq!(
+            yam_req_code, 1,
+            "yamllint require exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_req_msg, yam_req_msg,
+            "missing marker diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_require_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_require_ok.arg("-c").arg(&require_cfg).arg(&explicit);
+        let (ryl_req_ok_code, ryl_req_ok_msg) =
+            capture_with_env(ryl_require_ok, scenario.envs);
+
+        let mut yam_require_ok = build_yamllint_command(scenario.yam_format);
+        yam_require_ok.arg("-c").arg(&require_cfg).arg(&explicit);
+        let (yam_req_ok_code, yam_req_ok_msg) =
+            capture_with_env(yam_require_ok, scenario.envs);
+
+        assert_eq!(
+            ryl_req_ok_code, 0,
+            "ryl require pass exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_req_ok_code, 0,
+            "yamllint require pass exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_req_ok_msg, yam_req_ok_msg,
+            "require pass diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_forbid = build_ryl_command(exe, scenario.ryl_format);
+        ryl_forbid.arg("-c").arg(&forbid_cfg).arg(&explicit);
+        let (ryl_forbid_code, ryl_forbid_msg) =
+            capture_with_env(ryl_forbid, scenario.envs);
+
+        let mut yam_forbid = build_yamllint_command(scenario.yam_format);
+        yam_forbid.arg("-c").arg(&forbid_cfg).arg(&explicit);
+        let (yam_forbid_code, yam_forbid_msg) =
+            capture_with_env(yam_forbid, scenario.envs);
+
+        assert_eq!(ryl_forbid_code, 1, "ryl forbid exit ({})", scenario.label);
+        assert_eq!(
+            yam_forbid_code, 1,
+            "yamllint forbid exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_forbid_msg, yam_forbid_msg,
+            "forbid diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_forbid_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_forbid_ok.arg("-c").arg(&forbid_cfg).arg(&missing);
+        let (ryl_forbid_ok_code, ryl_forbid_ok_msg) =
+            capture_with_env(ryl_forbid_ok, scenario.envs);
+
+        let mut yam_forbid_ok = build_yamllint_command(scenario.yam_format);
+        yam_forbid_ok.arg("-c").arg(&forbid_cfg).arg(&missing);
+        let (yam_forbid_ok_code, yam_forbid_ok_msg) =
+            capture_with_env(yam_forbid_ok, scenario.envs);
+
+        assert_eq!(
+            ryl_forbid_ok_code, 0,
+            "ryl forbid pass exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_forbid_ok_code, 0,
+            "yamllint forbid pass exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_forbid_ok_msg, yam_forbid_ok_msg,
+            "forbid pass diagnostics mismatch ({})",
+            scenario.label
+        );
+    }
+}

package/tests/yamllint_compat_empty_lines.rs

@@ -0,0 +1,117 @@
+use std::fs;
+
+use tempfile::tempdir;
+
+#[path = "common/compat.rs"]
+mod compat;
+
+use compat::{
+    SCENARIOS, build_ryl_command, build_yamllint_command, capture_with_env,
+    ensure_yamllint_installed,
+};
+
+struct Case {
+    label: &'static str,
+    config: std::path::PathBuf,
+    target: std::path::PathBuf,
+    expected_exit: i32,
+}
+
+#[test]
+fn empty_lines_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let interior_file = dir.path().join("interior.yaml");
+    fs::write(&interior_file, "key: 1\n\n\nvalue: 2\n").unwrap();
+    let start_file = dir.path().join("start.yaml");
+    fs::write(&start_file, "\n\nkey: 1\n").unwrap();
+    let end_file = dir.path().join("end.yaml");
+    fs::write(&end_file, "key: 1\n\n\n").unwrap();
+
+    let interior_cfg = dir.path().join("interior.yml");
+    fs::write(
+        &interior_cfg,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    max: 1\n    max-start: 0\n    max-end: 0\n",
+    )
+    .unwrap();
+
+    let warning_cfg = dir.path().join("warning.yml");
+    fs::write(
+        &warning_cfg,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    level: warning\n    max: 1\n    max-start: 0\n    max-end: 0\n",
+    )
+    .unwrap();
+
+    let start_cfg = dir.path().join("start.yml");
+    fs::write(
+        &start_cfg,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    max: 5\n    max-start: 1\n    max-end: 5\n",
+    )
+    .unwrap();
+
+    let end_cfg = dir.path().join("end.yml");
+    fs::write(
+        &end_cfg,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    max: 5\n    max-start: 5\n    max-end: 1\n",
+    )
+    .unwrap();
+
+    let cases = vec![
+        Case {
+            label: "interior-error",
+            config: interior_cfg.clone(),
+            target: interior_file.clone(),
+            expected_exit: 1,
+        },
+        Case {
+            label: "interior-warning",
+            config: warning_cfg.clone(),
+            target: interior_file,
+            expected_exit: 0,
+        },
+        Case {
+            label: "start-error",
+            config: start_cfg.clone(),
+            target: start_file,
+            expected_exit: 1,
+        },
+        Case {
+            label: "end-error",
+            config: end_cfg.clone(),
+            target: end_file,
+            expected_exit: 1,
+        },
+    ];
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        for case in &cases {
+            let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
+            ryl_cmd.arg("-c").arg(&case.config).arg(&case.target);
+            let (ryl_code, ryl_output) = capture_with_env(ryl_cmd, scenario.envs);
+
+            let mut yam_cmd = build_yamllint_command(scenario.yam_format);
+            yam_cmd.arg("-c").arg(&case.config).arg(&case.target);
+            let (yam_code, yam_output) = capture_with_env(yam_cmd, scenario.envs);
+
+            assert_eq!(
+                ryl_code, case.expected_exit,
+                "ryl exit mismatch ({}/{})",
+                scenario.label, case.label
+            );
+            assert_eq!(
+                yam_code, case.expected_exit,
+                "yamllint exit mismatch ({}/{})",
+                scenario.label, case.label
+            );
+            assert_eq!(
+                ryl_output, yam_output,
+                "diagnostics mismatch ({}/{})",
+                scenario.label, case.label
+            );
+        }
+    }
+}

package/tests/yamllint_compat_empty_values.rs

@@ -0,0 +1,179 @@
+use std::fs;
+
+use tempfile::tempdir;
+
+#[path = "common/compat.rs"]
+mod compat;
+
+use compat::{
+    SCENARIOS, build_ryl_command, build_yamllint_command, capture_with_env,
+    ensure_yamllint_installed,
+};
+
+#[test]
+fn empty_values_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let violations = dir.path().join("violations.yaml");
+    fs::write(
+        &violations,
+        "block:\n  missing:\nflow: { missing: }\nseq:\n  -\n",
+    )
+    .unwrap();
+
+    let clean = dir.path().join("clean.yaml");
+    fs::write(
+        &clean,
+        "block:\n  present: value\nflow: { present: value }\nseq:\n  - value\n",
+    )
+    .unwrap();
+
+    let all_cfg = dir.path().join("empty-all.yml");
+    fs::write(
+        &all_cfg,
+        "rules:\n  document-start: disable\n  empty-values: enable\n",
+    )
+    .unwrap();
+
+    let block_cfg = dir.path().join("empty-block.yml");
+    fs::write(
+        &block_cfg,
+        "rules:\n  document-start: disable\n  empty-values:\n    forbid-in-block-mappings: true\n    forbid-in-flow-mappings: false\n    forbid-in-block-sequences: false\n",
+    )
+    .unwrap();
+
+    let flow_cfg = dir.path().join("empty-flow.yml");
+    fs::write(
+        &flow_cfg,
+        "rules:\n  document-start: disable\n  empty-values:\n    forbid-in-block-mappings: false\n    forbid-in-flow-mappings: true\n    forbid-in-block-sequences: false\n",
+    )
+    .unwrap();
+
+    let seq_cfg = dir.path().join("empty-seq.yml");
+    fs::write(
+        &seq_cfg,
+        "rules:\n  document-start: disable\n  empty-values:\n    forbid-in-block-mappings: false\n    forbid-in-flow-mappings: false\n    forbid-in-block-sequences: true\n",
+    )
+    .unwrap();
+
+    let none_cfg = dir.path().join("empty-none.yml");
+    fs::write(
+        &none_cfg,
+        "rules:\n  document-start: disable\n  empty-values:\n    forbid-in-block-mappings: false\n    forbid-in-flow-mappings: false\n    forbid-in-block-sequences: false\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        let mut ryl_all = build_ryl_command(exe, scenario.ryl_format);
+        ryl_all.arg("-c").arg(&all_cfg).arg(&violations);
+        let (ryl_all_code, ryl_all_msg) = capture_with_env(ryl_all, scenario.envs);
+
+        let mut yam_all = build_yamllint_command(scenario.yam_format);
+        yam_all.arg("-c").arg(&all_cfg).arg(&violations);
+        let (yam_all_code, yam_all_msg) = capture_with_env(yam_all, scenario.envs);
+
+        assert_eq!(ryl_all_code, 1, "ryl all exit ({})", scenario.label);
+        assert_eq!(yam_all_code, 1, "yamllint all exit ({})", scenario.label);
+        assert_eq!(
+            ryl_all_msg, yam_all_msg,
+            "all diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_block = build_ryl_command(exe, scenario.ryl_format);
+        ryl_block.arg("-c").arg(&block_cfg).arg(&violations);
+        let (ryl_block_code, ryl_block_msg) =
+            capture_with_env(ryl_block, scenario.envs);
+
+        let mut yam_block = build_yamllint_command(scenario.yam_format);
+        yam_block.arg("-c").arg(&block_cfg).arg(&violations);
+        let (yam_block_code, yam_block_msg) =
+            capture_with_env(yam_block, scenario.envs);
+
+        assert_eq!(ryl_block_code, 1, "ryl block exit ({})", scenario.label);
+        assert_eq!(
+            yam_block_code, 1,
+            "yamllint block exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_block_msg, yam_block_msg,
+            "block diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_flow = build_ryl_command(exe, scenario.ryl_format);
+        ryl_flow.arg("-c").arg(&flow_cfg).arg(&violations);
+        let (ryl_flow_code, ryl_flow_msg) = capture_with_env(ryl_flow, scenario.envs);
+
+        let mut yam_flow = build_yamllint_command(scenario.yam_format);
+        yam_flow.arg("-c").arg(&flow_cfg).arg(&violations);
+        let (yam_flow_code, yam_flow_msg) = capture_with_env(yam_flow, scenario.envs);
+
+        assert_eq!(ryl_flow_code, 1, "ryl flow exit ({})", scenario.label);
+        assert_eq!(yam_flow_code, 1, "yamllint flow exit ({})", scenario.label);
+        assert_eq!(
+            ryl_flow_msg, yam_flow_msg,
+            "flow diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_seq = build_ryl_command(exe, scenario.ryl_format);
+        ryl_seq.arg("-c").arg(&seq_cfg).arg(&violations);
+        let (ryl_seq_code, ryl_seq_msg) = capture_with_env(ryl_seq, scenario.envs);
+
+        let mut yam_seq = build_yamllint_command(scenario.yam_format);
+        yam_seq.arg("-c").arg(&seq_cfg).arg(&violations);
+        let (yam_seq_code, yam_seq_msg) = capture_with_env(yam_seq, scenario.envs);
+
+        assert_eq!(ryl_seq_code, 1, "ryl seq exit ({})", scenario.label);
+        assert_eq!(yam_seq_code, 1, "yamllint seq exit ({})", scenario.label);
+        assert_eq!(
+            ryl_seq_msg, yam_seq_msg,
+            "seq diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_none = build_ryl_command(exe, scenario.ryl_format);
+        ryl_none.arg("-c").arg(&none_cfg).arg(&violations);
+        let (ryl_none_code, ryl_none_msg) = capture_with_env(ryl_none, scenario.envs);
+
+        let mut yam_none = build_yamllint_command(scenario.yam_format);
+        yam_none.arg("-c").arg(&none_cfg).arg(&violations);
+        let (yam_none_code, yam_none_msg) = capture_with_env(yam_none, scenario.envs);
+
+        assert_eq!(ryl_none_code, 0, "ryl none exit ({})", scenario.label);
+        assert_eq!(yam_none_code, 0, "yamllint none exit ({})", scenario.label);
+        assert_eq!(
+            ryl_none_msg, yam_none_msg,
+            "none diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_clean = build_ryl_command(exe, scenario.ryl_format);
+        ryl_clean.arg("-c").arg(&all_cfg).arg(&clean);
+        let (ryl_clean_code, ryl_clean_msg) =
+            capture_with_env(ryl_clean, scenario.envs);
+
+        let mut yam_clean = build_yamllint_command(scenario.yam_format);
+        yam_clean.arg("-c").arg(&all_cfg).arg(&clean);
+        let (yam_clean_code, yam_clean_msg) =
+            capture_with_env(yam_clean, scenario.envs);
+
+        assert_eq!(ryl_clean_code, 0, "ryl clean exit ({})", scenario.label);
+        assert_eq!(
+            yam_clean_code, 0,
+            "yamllint clean exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_clean_msg, yam_clean_msg,
+            "clean diagnostics mismatch ({})",
+            scenario.label
+        );
+    }
+}

package/tests/yamllint_compat_float_values.rs

@@ -0,0 +1,216 @@
+use std::fs;
+
+use tempfile::tempdir;
+
+#[path = "common/compat.rs"]
+mod compat;
+
+use compat::{
+    SCENARIOS, build_ryl_command, build_yamllint_command, capture_with_env,
+    ensure_yamllint_installed,
+};
+
+#[test]
+fn float_values_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let violations = dir.path().join("violations.yaml");
+    fs::write(&violations, "a: .5\nb: 1e2\nc: .nan\nd: .inf\n").unwrap();
+
+    let ok = dir.path().join("ok.yaml");
+    fs::write(&ok, "a: 0.5\nb: 10.0\nc: 0.0\n").unwrap();
+
+    let default_cfg = dir.path().join("float-default.yml");
+    fs::write(
+        &default_cfg,
+        "rules:\n  document-start: disable\n  float-values: enable\n",
+    )
+    .unwrap();
+
+    let require_cfg = dir.path().join("float-require.yml");
+    fs::write(
+        &require_cfg,
+        "rules:\n  document-start: disable\n  float-values:\n    require-numeral-before-decimal: true\n",
+    )
+    .unwrap();
+
+    let scientific_cfg = dir.path().join("float-scientific.yml");
+    fs::write(
+        &scientific_cfg,
+        "rules:\n  document-start: disable\n  float-values:\n    forbid-scientific-notation: true\n",
+    )
+    .unwrap();
+
+    let nan_cfg = dir.path().join("float-nan.yml");
+    fs::write(
+        &nan_cfg,
+        "rules:\n  document-start: disable\n  float-values:\n    forbid-nan: true\n",
+    )
+    .unwrap();
+
+    let inf_cfg = dir.path().join("float-inf.yml");
+    fs::write(
+        &inf_cfg,
+        "rules:\n  document-start: disable\n  float-values:\n    forbid-inf: true\n",
+    )
+    .unwrap();
+
+    let all_cfg = dir.path().join("float-all.yml");
+    fs::write(
+        &all_cfg,
+        "rules:\n  document-start: disable\n  float-values:\n    require-numeral-before-decimal: true\n    forbid-scientific-notation: true\n    forbid-nan: true\n    forbid-inf: true\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        // Default configuration should not flag anything
+        let mut ryl_default = build_ryl_command(exe, scenario.ryl_format);
+        ryl_default.arg("-c").arg(&default_cfg).arg(&violations);
+        let (ryl_default_code, ryl_default_msg) =
+            capture_with_env(ryl_default, scenario.envs);
+
+        let mut yam_default = build_yamllint_command(scenario.yam_format);
+        yam_default.arg("-c").arg(&default_cfg).arg(&violations);
+        let (yam_default_code, yam_default_msg) =
+            capture_with_env(yam_default, scenario.envs);
+
+        assert_eq!(ryl_default_code, 0, "ryl default exit ({})", scenario.label);
+        assert_eq!(
+            yam_default_code, 0,
+            "yamllint default exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_default_msg, yam_default_msg,
+            "default diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // require-numeral-before-decimal
+        let mut ryl_require = build_ryl_command(exe, scenario.ryl_format);
+        ryl_require.arg("-c").arg(&require_cfg).arg(&violations);
+        let (ryl_require_code, ryl_require_msg) =
+            capture_with_env(ryl_require, scenario.envs);
+
+        let mut yam_require = build_yamllint_command(scenario.yam_format);
+        yam_require.arg("-c").arg(&require_cfg).arg(&violations);
+        let (yam_require_code, yam_require_msg) =
+            capture_with_env(yam_require, scenario.envs);
+
+        assert_eq!(ryl_require_code, 1, "ryl require exit ({})", scenario.label);
+        assert_eq!(
+            yam_require_code, 1,
+            "yamllint require exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_require_msg, yam_require_msg,
+            "require diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // forbid-scientific-notation
+        let mut ryl_scientific = build_ryl_command(exe, scenario.ryl_format);
+        ryl_scientific
+            .arg("-c")
+            .arg(&scientific_cfg)
+            .arg(&violations);
+        let (ryl_scientific_code, ryl_scientific_msg) =
+            capture_with_env(ryl_scientific, scenario.envs);
+
+        let mut yam_scientific = build_yamllint_command(scenario.yam_format);
+        yam_scientific
+            .arg("-c")
+            .arg(&scientific_cfg)
+            .arg(&violations);
+        let (yam_scientific_code, yam_scientific_msg) =
+            capture_with_env(yam_scientific, scenario.envs);
+
+        assert_eq!(
+            ryl_scientific_code, 1,
+            "ryl scientific exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_scientific_code, 1,
+            "yamllint scientific exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_scientific_msg, yam_scientific_msg,
+            "scientific diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // forbid-nan
+        let mut ryl_nan = build_ryl_command(exe, scenario.ryl_format);
+        ryl_nan.arg("-c").arg(&nan_cfg).arg(&violations);
+        let (ryl_nan_code, ryl_nan_msg) = capture_with_env(ryl_nan, scenario.envs);
+
+        let mut yam_nan = build_yamllint_command(scenario.yam_format);
+        yam_nan.arg("-c").arg(&nan_cfg).arg(&violations);
+        let (yam_nan_code, yam_nan_msg) = capture_with_env(yam_nan, scenario.envs);
+
+        assert_eq!(ryl_nan_code, 1, "ryl nan exit ({})", scenario.label);
+        assert_eq!(yam_nan_code, 1, "yamllint nan exit ({})", scenario.label);
+        assert_eq!(
+            ryl_nan_msg, yam_nan_msg,
+            "nan diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // forbid-inf
+        let mut ryl_inf = build_ryl_command(exe, scenario.ryl_format);
+        ryl_inf.arg("-c").arg(&inf_cfg).arg(&violations);
+        let (ryl_inf_code, ryl_inf_msg) = capture_with_env(ryl_inf, scenario.envs);
+
+        let mut yam_inf = build_yamllint_command(scenario.yam_format);
+        yam_inf.arg("-c").arg(&inf_cfg).arg(&violations);
+        let (yam_inf_code, yam_inf_msg) = capture_with_env(yam_inf, scenario.envs);
+
+        assert_eq!(ryl_inf_code, 1, "ryl inf exit ({})", scenario.label);
+        assert_eq!(yam_inf_code, 1, "yamllint inf exit ({})", scenario.label);
+        assert_eq!(
+            ryl_inf_msg, yam_inf_msg,
+            "inf diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // all options enabled, expect four diagnostics, and ok file passes
+        let mut ryl_all = build_ryl_command(exe, scenario.ryl_format);
+        ryl_all.arg("-c").arg(&all_cfg).arg(&violations);
+        let (ryl_all_code, ryl_all_msg) = capture_with_env(ryl_all, scenario.envs);
+
+        let mut yam_all = build_yamllint_command(scenario.yam_format);
+        yam_all.arg("-c").arg(&all_cfg).arg(&violations);
+        let (yam_all_code, yam_all_msg) = capture_with_env(yam_all, scenario.envs);
+
+        assert_eq!(ryl_all_code, 1, "ryl all exit ({})", scenario.label);
+        assert_eq!(yam_all_code, 1, "yamllint all exit ({})", scenario.label);
+        assert_eq!(
+            ryl_all_msg, yam_all_msg,
+            "all diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_ok.arg("-c").arg(&all_cfg).arg(&ok);
+        let (ryl_ok_code, ryl_ok_msg) = capture_with_env(ryl_ok, scenario.envs);
+
+        let mut yam_ok = build_yamllint_command(scenario.yam_format);
+        yam_ok.arg("-c").arg(&all_cfg).arg(&ok);
+        let (yam_ok_code, yam_ok_msg) = capture_with_env(yam_ok, scenario.envs);
+
+        assert_eq!(ryl_ok_code, 0, "ryl ok exit ({})", scenario.label);
+        assert_eq!(yam_ok_code, 0, "yamllint ok exit ({})", scenario.label);
+        assert_eq!(
+            ryl_ok_msg, yam_ok_msg,
+            "ok diagnostics mismatch ({})",
+            scenario.label
+        );
+    }
+}