@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/yamllint_compat_comments_indentation.rs

@@ -1,281 +0,0 @@
-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 comments_indentation_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let enable_cfg = dir.path().join("comments-enable.yml");
-    fs::write(
-        &enable_cfg,
-        "rules:\n  document-start: disable\n  comments-indentation: enable\n",
-    )
-    .unwrap();
-
-    let warning_cfg = dir.path().join("comments-warning.yml");
-    fs::write(
-        &warning_cfg,
-        "rules:\n  document-start: disable\n  comments-indentation:\n    level: warning\n",
-    )
-    .unwrap();
-
-    let ignore_cfg = dir.path().join("comments-ignore.yml");
-    fs::write(
-        &ignore_cfg,
-        "rules:\n  document-start: disable\n  comments-indentation:\n    ignore:\n      - ignored.yaml\n",
-    )
-    .unwrap();
-
-    let ignore_list = dir.path().join("comments-ignore.txt");
-    fs::write(&ignore_list, "ignored-from-file.yaml\n").unwrap();
-
-    let ignore_from_file_cfg = dir.path().join("comments-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  comments-indentation:\n    ignore-from-file: '{}'\n",
-            ignore_path
-        ),
-    )
-    .unwrap();
-
-    let bad_file = dir.path().join("bad.yaml");
-    fs::write(&bad_file, "obj:\n # wrong\n  value: 1\n").unwrap();
-
-    let ignored_file = dir.path().join("ignored.yaml");
-    fs::write(&ignored_file, "obj:\n # wrong\n  value: 1\n").unwrap();
-
-    let ignored_from_file = dir.path().join("ignored-from-file.yaml");
-    fs::write(&ignored_from_file, "obj:\n # wrong\n  value: 1\n").unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        let mut ryl_enable = build_ryl_command(exe, scenario.ryl_format);
-        ryl_enable.arg("-c").arg(&enable_cfg).arg(&bad_file);
-        let (ryl_code, ryl_output) = capture_with_env(ryl_enable, scenario.envs);
-
-        let mut yam_enable = build_yamllint_command(scenario.yam_format);
-        yam_enable.arg("-c").arg(&enable_cfg).arg(&bad_file);
-        let (yam_code, yam_output) = capture_with_env(yam_enable, scenario.envs);
-
-        assert_eq!(ryl_code, 1, "ryl enable exit ({})", scenario.label);
-        assert_eq!(yam_code, 1, "yamllint enable exit ({})", scenario.label);
-        assert_eq!(
-            ryl_output, yam_output,
-            "enable diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        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
-        );
-
-        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
-        );
-
-        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
-        );
-    }
-}
-
-#[test]
-fn comments_around_line_length_toggle_match_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-    let cfg = dir.path().join("cfg.yml");
-    fs::write(
-        &cfg,
-        "extends: default\nrules:\n  line-length:\n    max: 110\n",
-    )
-    .unwrap();
-
-    let input = dir.path().join("input.yml");
-    fs::write(
-        &input,
-        "body:\n  - type: markdown\n    attributes:\n      # yamllint disable rule:line-length\n      value: |\n        hello\n      # yamllint enable rule:line-length\n",
-    )
-    .unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
-        ryl_cmd.arg("-c").arg(&cfg).arg(&input);
-        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(&cfg).arg(&input);
-        let (yam_code, yam_msg) = capture_with_env(yam_cmd, scenario.envs);
-
-        assert_eq!(
-            ryl_code, yam_code,
-            "exit mismatch for comments around line-length toggle ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_msg, yam_msg,
-            "diagnostics mismatch for comments around line-length toggle ({})",
-            scenario.label
-        );
-    }
-}
-
-#[test]
-fn comment_after_block_scalar_pattern_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-    let cfg = dir.path().join("cfg.yml");
-    fs::write(
-        &cfg,
-        "extends: default\nrules:\n  line-length:\n    max: 110\n",
-    )
-    .unwrap();
-
-    let input = dir.path().join("input.yml");
-    fs::write(
-        &input,
-        "---\nhooks:\n  - id: x\n    files: >\n      (?x)\n      ^a$|\n      ^b$\n    ## ONLY ADD PREK HOOKS HERE THAT REQUIRE CI IMAGE\n  - id: y\n",
-    )
-    .unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-    for scenario in SCENARIOS {
-        let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
-        ryl_cmd.arg("-c").arg(&cfg).arg("--strict").arg(&input);
-        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(&cfg).arg("--strict").arg(&input);
-        let (yam_code, yam_msg) = capture_with_env(yam_cmd, scenario.envs);
-
-        assert_eq!(
-            ryl_code, yam_code,
-            "exit mismatch for comment after block scalar pattern ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_msg, yam_msg,
-            "diagnostics mismatch for comment after block scalar pattern ({})",
-            scenario.label
-        );
-    }
-}
-
-#[test]
-fn explicit_key_block_scalar_comment_content_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-    let cfg = dir.path().join("cfg.yml");
-    fs::write(
-        &cfg,
-        "rules:\n  document-start: disable\n  comments-indentation: enable\n",
-    )
-    .unwrap();
-
-    let input = dir.path().join("input.yml");
-    fs::write(&input, "? |\n  # block scalar content\n: value\n").unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-    for scenario in SCENARIOS {
-        let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
-        ryl_cmd.arg("-c").arg(&cfg).arg(&input);
-        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(&cfg).arg(&input);
-        let (yam_code, yam_msg) = capture_with_env(yam_cmd, scenario.envs);
-
-        assert_eq!(
-            ryl_code, yam_code,
-            "exit mismatch for explicit-key block scalar comment content ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_msg, yam_msg,
-            "diagnostics mismatch for explicit-key block scalar comment content ({})",
-            scenario.label
-        );
-    }
-}

package/tests/yamllint_compat_config.rs

@@ -1,170 +0,0 @@
-use std::fs;
-use std::process::Command;
-
-use tempfile::tempdir;
-
-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"
-    );
-}
-
-fn run(cmd: &mut Command) -> (i32, String, String) {
-    let out = cmd.output().expect("failed to run command");
-    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)
-}
-
-#[test]
-fn yamllint_and_ryl_honor_ignore_from_file() {
-    ensure_yamllint_installed();
-
-    let td = tempdir().unwrap();
-    let root = td.path();
-    fs::write(
-        root.join(".yamllint"),
-        "ignore-from-file: patterns.ignore\nrules: {}\n",
-    )
-    .unwrap();
-    fs::write(root.join("patterns.ignore"), "*.skip.yaml\n").unwrap();
-    fs::write(root.join("keep.yaml"), "ok: 1\n").unwrap();
-    fs::write(root.join("skip.yaml"), "bad: [1\n").unwrap();
-
-    let ryl = env!("CARGO_BIN_EXE_ryl");
-    let (_code, ryl_out, ryl_err) = run(Command::new(ryl)
-        .current_dir(root)
-        .arg("--list-files")
-        .arg("."));
-    assert!(ryl_err.is_empty(), "unexpected stderr from ryl: {ryl_err}");
-    let mut ryl_list: Vec<_> = ryl_out.lines().map(|s| s.to_string()).collect();
-    ryl_list.sort();
-
-    let (_yc, y_out, y_err) = run(Command::new("yamllint")
-        .current_dir(root)
-        .arg("--list-files")
-        .arg("."));
-    assert!(y_err.is_empty(), "unexpected stderr from yamllint: {y_err}");
-    let mut y_list: Vec<_> = y_out.lines().map(|s| s.to_string()).collect();
-    y_list.sort();
-
-    assert_eq!(ryl_list, y_list, "file lists should match");
-}
-
-#[test]
-fn project_config_precedence_over_env_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let td = tempdir().unwrap();
-    let root = td.path();
-    fs::write(
-        root.join(".yamllint"),
-        "ignore: ['ignored.yaml']\nrules: {}\n",
-    )
-    .unwrap();
-    let env_cfg = root.join("env.yaml");
-    fs::write(&env_cfg, "rules: {}\n").unwrap();
-    fs::write(root.join("ignored.yaml"), "ok: 1\n").unwrap();
-    fs::write(root.join("keep.yaml"), "ok: 1\n").unwrap();
-
-    let ryl = env!("CARGO_BIN_EXE_ryl");
-    let (_code, ryl_out, ryl_err) = run(Command::new(ryl)
-        .current_dir(root)
-        .env("YAMLLINT_CONFIG_FILE", env_cfg.display().to_string())
-        .arg("--list-files")
-        .arg("."));
-    assert!(ryl_err.is_empty(), "unexpected stderr from ryl: {ryl_err}");
-    let mut ryl_list: Vec<_> = ryl_out.lines().map(|s| s.to_string()).collect();
-    ryl_list.sort();
-
-    let (_yc, y_out, y_err) = run(Command::new("yamllint")
-        .current_dir(root)
-        .env("YAMLLINT_CONFIG_FILE", env_cfg.display().to_string())
-        .arg("--list-files")
-        .arg("."));
-    assert!(y_err.is_empty(), "unexpected stderr from yamllint: {y_err}");
-    let mut y_list: Vec<_> = y_out.lines().map(|s| s.to_string()).collect();
-    y_list.sort();
-
-    assert_eq!(ryl_list, y_list, "project config should take precedence");
-}
-
-#[test]
-fn ignore_can_reinclude_file_from_excluded_directory_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let td = tempdir().unwrap();
-    let root = td.path();
-    fs::write(
-        root.join(".yamllint"),
-        "ignore: |\n  build/\n  !build/keep.yaml\nrules: {}\n",
-    )
-    .unwrap();
-    fs::create_dir_all(root.join("build")).unwrap();
-    fs::write(root.join("build/keep.yaml"), "ok: 1\n").unwrap();
-    fs::write(root.join("build/drop.yaml"), "ok: 1\n").unwrap();
-    fs::write(root.join("top.yaml"), "ok: 1\n").unwrap();
-
-    let ryl = env!("CARGO_BIN_EXE_ryl");
-    let (_code, ryl_out, ryl_err) = run(Command::new(ryl)
-        .current_dir(root)
-        .arg("--list-files")
-        .arg("."));
-    assert!(ryl_err.is_empty(), "unexpected stderr from ryl: {ryl_err}");
-    let mut ryl_list: Vec<_> = ryl_out.lines().map(|s| s.to_string()).collect();
-    ryl_list.sort();
-
-    let (_yc, y_out, y_err) = run(Command::new("yamllint")
-        .current_dir(root)
-        .arg("--list-files")
-        .arg("."));
-    assert!(y_err.is_empty(), "unexpected stderr from yamllint: {y_err}");
-    let mut y_list: Vec<_> = y_out.lines().map(|s| s.to_string()).collect();
-    y_list.sort();
-
-    assert_eq!(ryl_list, y_list, "file lists should match");
-}
-
-#[test]
-fn ignore_from_file_can_reinclude_file_from_excluded_directory_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let td = tempdir().unwrap();
-    let root = td.path();
-    fs::write(
-        root.join(".yamllint"),
-        "ignore-from-file: patterns.ignore\nrules: {}\n",
-    )
-    .unwrap();
-    fs::write(root.join("patterns.ignore"), "build/\n!build/keep.yaml\n").unwrap();
-    fs::create_dir_all(root.join("build")).unwrap();
-    fs::write(root.join("build/keep.yaml"), "ok: 1\n").unwrap();
-    fs::write(root.join("build/drop.yaml"), "ok: 1\n").unwrap();
-    fs::write(root.join("top.yaml"), "ok: 1\n").unwrap();
-
-    let ryl = env!("CARGO_BIN_EXE_ryl");
-    let (_code, ryl_out, ryl_err) = run(Command::new(ryl)
-        .current_dir(root)
-        .arg("--list-files")
-        .arg("."));
-    assert!(ryl_err.is_empty(), "unexpected stderr from ryl: {ryl_err}");
-    let mut ryl_list: Vec<_> = ryl_out.lines().map(|s| s.to_string()).collect();
-    ryl_list.sort();
-
-    let (_yc, y_out, y_err) = run(Command::new("yamllint")
-        .current_dir(root)
-        .arg("--list-files")
-        .arg("."));
-    assert!(y_err.is_empty(), "unexpected stderr from yamllint: {y_err}");
-    let mut y_list: Vec<_> = y_out.lines().map(|s| s.to_string()).collect();
-    y_list.sort();
-
-    assert_eq!(ryl_list, y_list, "file lists should match");
-}

package/tests/yamllint_compat_document_end.rs

@@ -1,243 +0,0 @@
-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_end_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let missing = dir.path().join("missing.yaml");
-    fs::write(&missing, "---\nfoo: bar\n").unwrap();
-
-    let explicit = dir.path().join("explicit.yaml");
-    fs::write(&explicit, "---\nfoo: bar\n...\n").unwrap();
-
-    let explicit_with_comment = dir.path().join("explicit_with_comment.yaml");
-    fs::write(&explicit_with_comment, "---\nfoo: bar\n... # done\n").unwrap();
-
-    let require_cfg = dir.path().join("require.yml");
-    fs::write(
-        &require_cfg,
-        "rules:\n  document-end:\n    level: error\n    present: true\n",
-    )
-    .unwrap();
-
-    let forbid_cfg = dir.path().join("forbid.yml");
-    fs::write(
-        &forbid_cfg,
-        "rules:\n  document-end:\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_require_comment = build_ryl_command(exe, scenario.ryl_format);
-        ryl_require_comment
-            .arg("-c")
-            .arg(&require_cfg)
-            .arg(&explicit_with_comment);
-        let (ryl_req_comment_code, ryl_req_comment_msg) =
-            capture_with_env(ryl_require_comment, scenario.envs);
-
-        let mut yam_require_comment = build_yamllint_command(scenario.yam_format);
-        yam_require_comment
-            .arg("-c")
-            .arg(&require_cfg)
-            .arg(&explicit_with_comment);
-        let (yam_req_comment_code, yam_req_comment_msg) =
-            capture_with_env(yam_require_comment, scenario.envs);
-
-        assert_eq!(
-            ryl_req_comment_code, 0,
-            "ryl require pass (with comment) exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_req_comment_code, 0,
-            "yamllint require pass (with comment) exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_req_comment_msg, yam_req_comment_msg,
-            "require comment 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_comment = build_ryl_command(exe, scenario.ryl_format);
-        ryl_forbid_comment
-            .arg("-c")
-            .arg(&forbid_cfg)
-            .arg(&explicit_with_comment);
-        let (ryl_forbid_comment_code, ryl_forbid_comment_msg) =
-            capture_with_env(ryl_forbid_comment, scenario.envs);
-
-        let mut yam_forbid_comment = build_yamllint_command(scenario.yam_format);
-        yam_forbid_comment
-            .arg("-c")
-            .arg(&forbid_cfg)
-            .arg(&explicit_with_comment);
-        let (yam_forbid_comment_code, yam_forbid_comment_msg) =
-            capture_with_env(yam_forbid_comment, scenario.envs);
-
-        assert_eq!(
-            ryl_forbid_comment_code, 1,
-            "ryl forbid comment exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_forbid_comment_code, 1,
-            "yamllint forbid comment exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_forbid_comment_msg, yam_forbid_comment_msg,
-            "forbid comment 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
-        );
-    }
-}
-
-#[test]
-fn document_end_handles_unicode_scalars() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let cfg_path = dir.path().join("config.yaml");
-    fs::write(
-        &cfg_path,
-        "rules:\n  document-start: disable\n  document-end:\n    level: error\n    present: false\n",
-    )
-    .unwrap();
-
-    let yaml_path = dir.path().join("unicode.yaml");
-    fs::write(
-        &yaml_path,
-        "set_room_temperature:\n  fields:\n    comfort_temp:\n      selector:\n        number:\n          min: 0\n          max: 100\n          unit_of_measurement: \"°\"\n",
-    )
-    .unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
-        ryl_cmd.arg("-c").arg(&cfg_path).arg(&yaml_path);
-        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(&cfg_path).arg(&yaml_path);
-        let (yam_code, yam_output) = capture_with_env(yam_cmd, scenario.envs);
-
-        assert_eq!(ryl_code, yam_code, "exit mismatch ({})", scenario.label);
-        assert_eq!(
-            ryl_output, yam_output,
-            "diagnostics mismatch ({})",
-            scenario.label
-        );
-    }
-}