@owenlamont/ryl 0.4.1

package/tests/yamllint_compat_quoted_strings.rs

@@ -0,0 +1,154 @@
+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<'a> {
+    label: &'a str,
+    config: &'a std::path::Path,
+    file: &'a std::path::Path,
+    exit: i32,
+}
+
+#[test]
+fn quoted_strings_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let default_cfg = dir.path().join("default.yaml");
+    fs::write(
+        &default_cfg,
+        "rules:\n  document-start: disable\n  quoted-strings: enable\n",
+    )
+    .unwrap();
+
+    let only_needed_cfg = dir.path().join("only-needed.yaml");
+    fs::write(
+        &only_needed_cfg,
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    )
+    .unwrap();
+
+    let extra_required_cfg = dir.path().join("extra-required.yaml");
+    fs::write(
+        &extra_required_cfg,
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: false\n    extra-required: ['^http']\n",
+    )
+    .unwrap();
+
+    let extra_allowed_cfg = dir.path().join("extra-allowed.yaml");
+    fs::write(
+        &extra_allowed_cfg,
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n    extra-allowed: ['^http']\n",
+    )
+    .unwrap();
+
+    let double_allow_cfg = dir.path().join("double-allow.yaml");
+    fs::write(
+        &double_allow_cfg,
+        "rules:\n  document-start: disable\n  quoted-strings:\n    quote-type: double\n    allow-quoted-quotes: true\n",
+    )
+    .unwrap();
+
+    let check_keys_cfg = dir.path().join("check-keys.yaml");
+    fs::write(
+        &check_keys_cfg,
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n    check-keys: true\n    extra-required: ['[:]']\n",
+    )
+    .unwrap();
+
+    let plain_file = dir.path().join("plain.yaml");
+    fs::write(&plain_file, "foo: bar\n").unwrap();
+
+    let quoted_file = dir.path().join("quoted.yaml");
+    fs::write(&quoted_file, "foo: \"bar\"\n").unwrap();
+
+    let url_file = dir.path().join("urls.yaml");
+    fs::write(&url_file, "- http://example.com\n").unwrap();
+
+    let allowed_url_file = dir.path().join("allowed-url.yaml");
+    fs::write(&allowed_url_file, "foo: \"http://example.com\"\n").unwrap();
+
+    let quoted_quotes_file = dir.path().join("quoted-quotes.yaml");
+    fs::write(&quoted_quotes_file, "foo: 'bar\"baz'\n").unwrap();
+
+    let key_file = dir.path().join("key.yaml");
+    fs::write(&key_file, "foo:bar: baz\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    let cases = [
+        Case {
+            label: "default-plain",
+            config: &default_cfg,
+            file: &plain_file,
+            exit: 1,
+        },
+        Case {
+            label: "only-needed-quoted",
+            config: &only_needed_cfg,
+            file: &quoted_file,
+            exit: 1,
+        },
+        Case {
+            label: "extra-required-url",
+            config: &extra_required_cfg,
+            file: &url_file,
+            exit: 1,
+        },
+        Case {
+            label: "extra-allowed-url",
+            config: &extra_allowed_cfg,
+            file: &allowed_url_file,
+            exit: 0,
+        },
+        Case {
+            label: "double-allow-quotes",
+            config: &double_allow_cfg,
+            file: &quoted_quotes_file,
+            exit: 0,
+        },
+        Case {
+            label: "check-keys",
+            config: &check_keys_cfg,
+            file: &key_file,
+            exit: 1,
+        },
+    ];
+
+    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.file);
+            let (ryl_code, ryl_msg) = 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.file);
+            let (yam_code, yam_msg) = capture_with_env(yam_cmd, scenario.envs);
+
+            assert_eq!(
+                ryl_code, case.exit,
+                "ryl exit mismatch {} ({})",
+                case.label, scenario.label
+            );
+            assert_eq!(
+                yam_code, case.exit,
+                "yamllint exit mismatch {} ({})",
+                case.label, scenario.label
+            );
+            assert_eq!(
+                ryl_msg, yam_msg,
+                "diagnostics mismatch {} ({})",
+                case.label, scenario.label
+            );
+        }
+    }
+}

package/tests/yamllint_compat_syntax.rs

@@ -0,0 +1,200 @@
+use std::fs;
+use std::path::PathBuf;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run_cmd(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("failed to spawn process");
+    let code = out.status.code().unwrap_or(-1);
+    let stdout = String::from_utf8_lossy(&out.stdout).into_owned();
+    let stderr = String::from_utf8_lossy(&out.stderr).into_owned();
+    (code, stdout, stderr)
+}
+
+fn run_with_env(
+    mut cmd: Command,
+    envs: &[(&str, Option<&str>)],
+) -> (i32, String, String) {
+    cmd.env_remove("GITHUB_ACTIONS");
+    cmd.env_remove("GITHUB_WORKFLOW");
+    cmd.env_remove("CI");
+    for (key, value) in envs {
+        if let Some(val) = value {
+            cmd.env(key, val);
+        } else {
+            cmd.env_remove(key);
+        }
+    }
+    run_cmd(&mut cmd)
+}
+
+fn write_file(dir: &std::path::Path, name: &str, content: &str) -> PathBuf {
+    let p = dir.join(name);
+    fs::write(&p, content).expect("write file");
+    p
+}
+
+fn ensure_yamllint_installed() {
+    let ok = Command::new("yamllint")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    assert!(
+        ok,
+        "yamllint must be installed and in PATH for parity tests"
+    );
+}
+
+#[test]
+fn yamllint_exit_behavior_matches_for_syntax_only() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let ok = write_file(dir.path(), "ok.yaml", "a: 1\n");
+    let bad = write_file(dir.path(), "bad.yaml", "a: [1, 2\n");
+
+    // Disable yamllint rules so we only compare syntax behavior.
+    let cfg = write_file(dir.path(), ".yamllint.yml", "rules: {}\n");
+
+    let ryl = env!("CARGO_BIN_EXE_ryl");
+
+    const STANDARD_ENV: &[(&str, Option<&str>)] = &[];
+    const GITHUB_ENV: &[(&str, Option<&str>)] = &[
+        ("GITHUB_ACTIONS", Some("true")),
+        ("GITHUB_WORKFLOW", Some("test-workflow")),
+        ("CI", Some("true")),
+    ];
+
+    #[derive(Clone, Copy)]
+    enum OutputKind {
+        Standard,
+        Github,
+    }
+
+    fn parse_loc(msg: &str, kind: OutputKind) -> Option<(String, usize, usize)> {
+        match kind {
+            OutputKind::Standard => {
+                let mut lines = msg.lines().filter(|l| !l.trim().is_empty());
+                let file = lines.next()?.trim().to_string();
+                let second = lines.next()?.trim_start();
+                let pos = second.split_whitespace().next()?;
+                let mut it = pos.split(':');
+                let line = it.next()?.parse().ok()?;
+                let col = it.next()?.parse().ok()?;
+                Some((file, line, col))
+            }
+            OutputKind::Github => {
+                let mut lines = msg.lines().filter(|l| !l.trim().is_empty());
+                let header = lines.next()?.trim();
+                let file = header.strip_prefix("::group::")?.to_string();
+                let detail = lines.next()?.trim();
+                let detail = detail.strip_prefix("::error ")?;
+                let mut parts = detail.splitn(2, "::");
+                let meta = parts.next()?; // file=...,line=...,col=...
+                let mut meta_parts = meta.split(',');
+                let file_part = meta_parts.next()?;
+                let line_part = meta_parts.next()?;
+                let col_part = meta_parts.next()?;
+                let file_path = file_part.strip_prefix("file=")?;
+                let line_str = line_part.strip_prefix("line=")?;
+                let col_str = col_part.strip_prefix("col=")?;
+                let line = line_str.parse().ok()?;
+                let col = col_str.parse().ok()?;
+                // Ensure metadata file matches header file after trimming.
+                if !file_path.ends_with(&file) {
+                    return None;
+                }
+                Some((file_path.to_string(), line, col))
+            }
+        }
+    }
+
+    let scenarios = [
+        ("standard", STANDARD_ENV, OutputKind::Standard, true),
+        ("github", GITHUB_ENV, OutputKind::Github, false),
+    ];
+
+    for (label, envs, kind, use_standard_format) in scenarios {
+        // Valid file should pass in both tools.
+        let mut ryl_ok_cmd = Command::new(ryl);
+        ryl_ok_cmd.arg(&ok);
+        let (ryl_ok, _, _) = run_with_env(ryl_ok_cmd, envs);
+        assert_eq!(ryl_ok, 0, "ryl should succeed for valid yaml ({label})");
+
+        let mut yam_ok_cmd = Command::new("yamllint");
+        if use_standard_format {
+            yam_ok_cmd.arg("-f").arg("standard");
+        }
+        yam_ok_cmd.arg("-c");
+        yam_ok_cmd.arg(&cfg);
+        yam_ok_cmd.arg(&ok);
+        let (yam_ok, _, yam_ok_err) = run_with_env(yam_ok_cmd, envs);
+        assert_eq!(
+            yam_ok, 0,
+            "yamllint should succeed for valid yaml ({label}): {yam_ok_err}"
+        );
+
+        // Invalid file should fail; capture whichever stream has content.
+        let mut ryl_bad_cmd = Command::new(ryl);
+        ryl_bad_cmd.arg(&bad);
+        let (ryl_bad_code, ryl_bad_out, ryl_bad_err) = run_with_env(ryl_bad_cmd, envs);
+        let mut yam_bad_cmd = Command::new("yamllint");
+        if use_standard_format {
+            yam_bad_cmd.arg("-f").arg("standard");
+        }
+        yam_bad_cmd.arg("-c");
+        yam_bad_cmd.arg(&cfg);
+        yam_bad_cmd.arg(&bad);
+        let (yam_bad_code, yam_bad_out, yam_bad_err) = run_with_env(yam_bad_cmd, envs);
+
+        assert_ne!(
+            ryl_bad_code, 0,
+            "ryl should fail for invalid yaml ({label})"
+        );
+        assert_ne!(
+            yam_bad_code, 0,
+            "yamllint should fail for invalid yaml ({label})"
+        );
+
+        let r_msg = if !ryl_bad_err.is_empty() {
+            ryl_bad_err
+        } else {
+            ryl_bad_out
+        };
+        let y_msg = if !yam_bad_out.is_empty() {
+            yam_bad_out
+        } else {
+            yam_bad_err
+        };
+
+        if let (Some((rf, rl, rc)), Some((yf, yl, yc))) =
+            (parse_loc(&r_msg, kind), parse_loc(&y_msg, kind))
+        {
+            assert!(
+                rf.ends_with("bad.yaml"),
+                "ryl location should reference bad.yaml ({label}): {rf}"
+            );
+            assert!(
+                yf.ends_with("bad.yaml"),
+                "yamllint location should reference bad.yaml ({label}): {yf}"
+            );
+            assert_eq!(rl, yl, "line numbers should match ({label})");
+            assert_eq!(rc, yc, "column numbers should match ({label})");
+        } else {
+            panic!(
+                "could not parse location ({label})\nryl:\n{r_msg}\nyamllint:\n{y_msg}"
+            );
+        }
+
+        assert!(
+            r_msg.contains("syntax error"),
+            "ryl output should mention syntax error ({label}): {r_msg}"
+        );
+        assert!(
+            y_msg.contains("syntax error"),
+            "yamllint output should mention syntax error ({label}): {y_msg}"
+        );
+    }
+}

package/tests/yamllint_compat_trailing_spaces.rs

@@ -0,0 +1,162 @@
+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 trailing_spaces_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let default_cfg = dir.path().join("trailing-default.yml");
+    fs::write(
+        &default_cfg,
+        "rules:\n  document-start: disable\n  trailing-spaces: enable\n",
+    )
+    .unwrap();
+
+    let warning_cfg = dir.path().join("trailing-warning.yml");
+    fs::write(
+        &warning_cfg,
+        "rules:\n  document-start: disable\n  trailing-spaces:\n    level: warning\n",
+    )
+    .unwrap();
+
+    let ignore_cfg = dir.path().join("trailing-ignore.yml");
+    fs::write(
+        &ignore_cfg,
+        "rules:\n  document-start: disable\n  trailing-spaces:\n    ignore:\n      - ignored.yaml\n",
+    )
+    .unwrap();
+
+    let ignore_list = dir.path().join("trailing-ignore.txt");
+    fs::write(&ignore_list, "ignored-from-file.yaml\n").unwrap();
+
+    let ignore_from_file_cfg = dir.path().join("trailing-ignore-from-file.yml");
+    let ignore_path = ignore_list.display().to_string().replace('\'', "''");
+    fs::write(
+        &ignore_from_file_cfg,
+        format!(
+            "rules:\n  document-start: disable\n  trailing-spaces:\n    ignore-from-file: '{}'\n",
+            ignore_path
+        ),
+    )
+    .unwrap();
+
+    let bad_file = dir.path().join("bad.yaml");
+    fs::write(&bad_file, "key: value \n").unwrap();
+
+    let ignored_file = dir.path().join("ignored.yaml");
+    fs::write(&ignored_file, "other: value \n").unwrap();
+
+    let ignored_from_file = dir.path().join("ignored-from-file.yaml");
+    fs::write(&ignored_from_file, "foo: bar \n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        // default configuration should produce an error
+        let mut ryl_default = build_ryl_command(exe, scenario.ryl_format);
+        ryl_default.arg("-c").arg(&default_cfg).arg(&bad_file);
+        let (ryl_code, ryl_output) = 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(&bad_file);
+        let (yam_code, yam_output) = capture_with_env(yam_default, scenario.envs);
+
+        assert_eq!(ryl_code, 1, "ryl default exit ({})", scenario.label);
+        assert_eq!(yam_code, 1, "yamllint default exit ({})", scenario.label);
+        assert_eq!(
+            ryl_output, yam_output,
+            "default diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // warning configuration should keep diagnostics but exit 0
+        let mut ryl_warning = build_ryl_command(exe, scenario.ryl_format);
+        ryl_warning.arg("-c").arg(&warning_cfg).arg(&bad_file);
+        let (ryl_warn_code, ryl_warn_output) =
+            capture_with_env(ryl_warning, scenario.envs);
+
+        let mut yam_warning = build_yamllint_command(scenario.yam_format);
+        yam_warning.arg("-c").arg(&warning_cfg).arg(&bad_file);
+        let (yam_warn_code, yam_warn_output) =
+            capture_with_env(yam_warning, scenario.envs);
+
+        assert_eq!(ryl_warn_code, 0, "ryl warning exit ({})", scenario.label);
+        assert_eq!(
+            yam_warn_code, 0,
+            "yamllint warning exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_warn_output, yam_warn_output,
+            "warning diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // ignore pattern applied through inline config should skip diagnostics
+        let mut ryl_ignore = build_ryl_command(exe, scenario.ryl_format);
+        ryl_ignore.arg("-c").arg(&ignore_cfg).arg(&ignored_file);
+        let (ryl_ignore_code, ryl_ignore_output) =
+            capture_with_env(ryl_ignore, scenario.envs);
+
+        let mut yam_ignore = build_yamllint_command(scenario.yam_format);
+        yam_ignore.arg("-c").arg(&ignore_cfg).arg(&ignored_file);
+        let (yam_ignore_code, yam_ignore_output) =
+            capture_with_env(yam_ignore, scenario.envs);
+
+        assert_eq!(ryl_ignore_code, 0, "ryl ignore exit ({})", scenario.label);
+        assert_eq!(
+            yam_ignore_code, 0,
+            "yamllint ignore exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_ignore_output, yam_ignore_output,
+            "ignore diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // ignore-from-file should behave the same
+        let mut ryl_ignore_file = build_ryl_command(exe, scenario.ryl_format);
+        ryl_ignore_file
+            .arg("-c")
+            .arg(&ignore_from_file_cfg)
+            .arg(&ignored_from_file);
+        let (ryl_file_code, ryl_file_output) =
+            capture_with_env(ryl_ignore_file, scenario.envs);
+
+        let mut yam_ignore_file = build_yamllint_command(scenario.yam_format);
+        yam_ignore_file
+            .arg("-c")
+            .arg(&ignore_from_file_cfg)
+            .arg(&ignored_from_file);
+        let (yam_file_code, yam_file_output) =
+            capture_with_env(yam_ignore_file, scenario.envs);
+
+        assert_eq!(
+            ryl_file_code, 0,
+            "ryl ignore-from-file exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_file_code, 0,
+            "yamllint ignore-from-file exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_file_output, yam_file_output,
+            "ignore-from-file diagnostics mismatch ({})",
+            scenario.label
+        );
+    }
+}

package/tests/yamllint_compat_truthy.rs

@@ -0,0 +1,130 @@
+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 truthy_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let default_cfg = dir.path().join("truthy-default.yml");
+    fs::write(
+        &default_cfg,
+        "rules:\n  document-start: disable\n  truthy: enable\n",
+    )
+    .unwrap();
+
+    let allowed_cfg = dir.path().join("truthy-allowed.yml");
+    fs::write(
+        &allowed_cfg,
+        "rules:\n  document-start: disable\n  truthy:\n    allowed-values: [\"yes\", \"no\"]\n",
+    )
+    .unwrap();
+
+    let check_keys_cfg = dir.path().join("truthy-check-keys.yml");
+    fs::write(
+        &check_keys_cfg,
+        "rules:\n  document-start: disable\n  truthy:\n    allowed-values: []\n    check-keys: false\n",
+    )
+    .unwrap();
+
+    let bad_file = dir.path().join("bad.yaml");
+    fs::write(&bad_file, "foo: True\nbar: yes\nTrue: 1\non: off\n").unwrap();
+
+    let allowed_file = dir.path().join("allowed.yaml");
+    fs::write(&allowed_file, "- yes\n- no\n- true\n- on\n").unwrap();
+
+    let ok_file = dir.path().join("ok.yaml");
+    fs::write(&ok_file, "foo: false\nbar: true\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        // default configuration, expect errors on keys and values
+        let mut ryl_default = build_ryl_command(exe, scenario.ryl_format);
+        ryl_default.arg("-c").arg(&default_cfg).arg(&bad_file);
+        let (ryl_code, ryl_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(&bad_file);
+        let (yam_code, yam_msg) = capture_with_env(yam_default, scenario.envs);
+
+        assert_eq!(ryl_code, 1, "ryl default exit ({})", scenario.label);
+        assert_eq!(yam_code, 1, "yamllint default exit ({})", scenario.label);
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "default diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // allowed-values override keeps yes/no allowed
+        let mut ryl_allowed = build_ryl_command(exe, scenario.ryl_format);
+        ryl_allowed.arg("-c").arg(&allowed_cfg).arg(&allowed_file);
+        let (ryl_allowed_code, ryl_allowed_msg) =
+            capture_with_env(ryl_allowed, scenario.envs);
+
+        let mut yam_allowed = build_yamllint_command(scenario.yam_format);
+        yam_allowed.arg("-c").arg(&allowed_cfg).arg(&allowed_file);
+        let (yam_allowed_code, yam_allowed_msg) =
+            capture_with_env(yam_allowed, scenario.envs);
+
+        assert_eq!(ryl_allowed_code, 1, "ryl allowed exit ({})", scenario.label);
+        assert_eq!(
+            yam_allowed_code, 1,
+            "yamllint allowed exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_allowed_msg, yam_allowed_msg,
+            "allowed diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // check-keys=false should suppress key diagnostics
+        let mut ryl_check_keys = build_ryl_command(exe, scenario.ryl_format);
+        ryl_check_keys.arg("-c").arg(&check_keys_cfg).arg(&bad_file);
+        let (ryl_ck_code, ryl_ck_msg) = capture_with_env(ryl_check_keys, scenario.envs);
+
+        let mut yam_check_keys = build_yamllint_command(scenario.yam_format);
+        yam_check_keys.arg("-c").arg(&check_keys_cfg).arg(&bad_file);
+        let (yam_ck_code, yam_ck_msg) = capture_with_env(yam_check_keys, scenario.envs);
+
+        assert_eq!(ryl_ck_code, 1, "ryl check-keys exit ({})", scenario.label);
+        assert_eq!(
+            yam_ck_code, 1,
+            "yamllint check-keys exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_ck_msg, yam_ck_msg,
+            "check-keys diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // success scenario: default config but compliant file
+        let mut ryl_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_ok.arg("-c").arg(&default_cfg).arg(&ok_file);
+        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(&default_cfg).arg(&ok_file);
+        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
+        );
+    }
+}