@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/yamllint_compat_key_duplicates.rs

@@ -1,139 +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 key_duplicates_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let default_cfg = dir.path().join("key-duplicates-default.yml");
-    fs::write(
-        &default_cfg,
-        "rules:\n  document-start: disable\n  key-duplicates: enable\n",
-    )
-    .unwrap();
-
-    let forbid_cfg = dir.path().join("key-duplicates-forbid.yml");
-    fs::write(
-        &forbid_cfg,
-        "rules:\n  document-start: disable\n  key-duplicates:\n    forbid-duplicated-merge-keys: true\n",
-    )
-    .unwrap();
-
-    let dup_bad = dir.path().join("dup-bad.yaml");
-    fs::write(&dup_bad, "foo: 1\nbar: 2\nfoo: 3\n").unwrap();
-
-    let dup_ok = dir.path().join("dup-ok.yaml");
-    fs::write(&dup_ok, "foo: 1\nbar: 2\n").unwrap();
-
-    let merge_dup = dir.path().join("merge-dup.yaml");
-    fs::write(
-        &merge_dup,
-        "anchor: &a\n  value: 1\nmerged:\n  <<: *a\n  <<: *a\n",
-    )
-    .unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        let mut ryl_bad = build_ryl_command(exe, scenario.ryl_format);
-        ryl_bad.arg("-c").arg(&default_cfg).arg(&dup_bad);
-        let (ryl_bad_code, ryl_bad_msg) = capture_with_env(ryl_bad, scenario.envs);
-
-        let mut yam_bad = build_yamllint_command(scenario.yam_format);
-        yam_bad.arg("-c").arg(&default_cfg).arg(&dup_bad);
-        let (yam_bad_code, yam_bad_msg) = capture_with_env(yam_bad, scenario.envs);
-
-        assert_eq!(ryl_bad_code, 1, "ryl dup exit ({})", scenario.label);
-        assert_eq!(yam_bad_code, 1, "yamllint dup exit ({})", scenario.label);
-        assert_eq!(
-            ryl_bad_msg, yam_bad_msg,
-            "duplicate diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_ok = build_ryl_command(exe, scenario.ryl_format);
-        ryl_ok.arg("-c").arg(&default_cfg).arg(&dup_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(&default_cfg).arg(&dup_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
-        );
-
-        let mut ryl_merge_default = build_ryl_command(exe, scenario.ryl_format);
-        ryl_merge_default
-            .arg("-c")
-            .arg(&default_cfg)
-            .arg(&merge_dup);
-        let (ryl_merge_def_code, ryl_merge_def_msg) =
-            capture_with_env(ryl_merge_default, scenario.envs);
-
-        let mut yam_merge_default = build_yamllint_command(scenario.yam_format);
-        yam_merge_default
-            .arg("-c")
-            .arg(&default_cfg)
-            .arg(&merge_dup);
-        let (yam_merge_def_code, yam_merge_def_msg) =
-            capture_with_env(yam_merge_default, scenario.envs);
-
-        assert_eq!(
-            ryl_merge_def_code, 0,
-            "ryl merge default exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_merge_def_code, 0,
-            "yamllint merge default exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_merge_def_msg, yam_merge_def_msg,
-            "merge default diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_merge_forbid = build_ryl_command(exe, scenario.ryl_format);
-        ryl_merge_forbid.arg("-c").arg(&forbid_cfg).arg(&merge_dup);
-        let (ryl_merge_forbid_code, ryl_merge_forbid_msg) =
-            capture_with_env(ryl_merge_forbid, scenario.envs);
-
-        let mut yam_merge_forbid = build_yamllint_command(scenario.yam_format);
-        yam_merge_forbid.arg("-c").arg(&forbid_cfg).arg(&merge_dup);
-        let (yam_merge_forbid_code, yam_merge_forbid_msg) =
-            capture_with_env(yam_merge_forbid, scenario.envs);
-
-        assert_eq!(
-            ryl_merge_forbid_code, 1,
-            "ryl merge forbid exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_merge_forbid_code, 1,
-            "yamllint merge forbid exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_merge_forbid_msg, yam_merge_forbid_msg,
-            "merge forbid diagnostics mismatch ({})",
-            scenario.label
-        );
-    }
-}

package/tests/yamllint_compat_key_ordering.rs

@@ -1,170 +0,0 @@
-use std::fs;
-use std::process::Command;
-
-use tempfile::tempdir;
-
-#[path = "common/compat.rs"]
-mod compat;
-
-use compat::{
-    SCENARIOS, STANDARD_ENV, build_ryl_command, build_yamllint_command,
-    capture_with_env, ensure_yamllint_installed,
-};
-
-#[test]
-fn key_ordering_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let default_cfg = dir.path().join("key-ordering-default.yml");
-    fs::write(
-        &default_cfg,
-        "rules:\n  document-start: disable\n  key-ordering: enable\n",
-    )
-    .unwrap();
-
-    let ignored_cfg = dir.path().join("key-ordering-ignored.yml");
-    fs::write(
-        &ignored_cfg,
-        "rules:\n  document-start: disable\n  key-ordering:\n    ignored-keys: [\"n(a|o)me\", \"^b\"]\n",
-    )
-    .unwrap();
-
-    let locale_cfg = dir.path().join("key-ordering-locale.yml");
-    fs::write(
-        &locale_cfg,
-        "locale: en_US.UTF-8\nrules:\n  document-start: disable\n  key-ordering: enable\n",
-    )
-    .unwrap();
-
-    let bad_block = dir.path().join("bad-block.yaml");
-    fs::write(
-        &bad_block,
-        "block mapping:\n  second: value\n  first: value\n",
-    )
-    .unwrap();
-
-    let good_block = dir.path().join("good-block.yaml");
-    fs::write(
-        &good_block,
-        "block mapping:\n  first: value\n  second: value\n  third: v\n",
-    )
-    .unwrap();
-
-    let ignored_file = dir.path().join("ignored.yaml");
-    fs::write(
-        &ignored_file,
-        "a:\nb:\nc:\nname: ignored\nfirst-name: ignored\nnome: ignored\ngnomes: ignored\nd:\ne:\nboat: ignored\n.boat: ERROR\ncall: ERROR\nf:\ng:\n",
-    )
-    .unwrap();
-
-    let locale_file = dir.path().join("locale.yaml");
-    fs::write(
-        &locale_file,
-        "- t-shirt: 1\n  T-shirt: 2\n  t-shirts: 3\n  T-shirts: 4\n- hair: true\n  haïr: true\n  hais: true\n  haïssable: true\n",
-    )
-    .unwrap();
-
-    // Probe locale availability before running the full matrix. Skip locale comparison when
-    // yamllint cannot set the configured locale.
-    let mut locale_probe = Command::new("yamllint");
-    locale_probe.arg("-c").arg(&locale_cfg).arg(&locale_file);
-    let (probe_code, probe_output) = capture_with_env(locale_probe, STANDARD_ENV);
-    let skip_locale = if probe_code != 0
-        && (probe_output.contains("unsupported locale")
-            || probe_output.contains("unknown locale"))
-    {
-        eprintln!("skipping locale comparison: {probe_output}");
-        true
-    } else {
-        false
-    };
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        // default configuration, expect violations on bad block
-        let mut ryl_bad = build_ryl_command(exe, scenario.ryl_format);
-        ryl_bad.arg("-c").arg(&default_cfg).arg(&bad_block);
-        let (ryl_bad_code, ryl_bad_msg) = capture_with_env(ryl_bad, scenario.envs);
-
-        let mut yam_bad = build_yamllint_command(scenario.yam_format);
-        yam_bad.arg("-c").arg(&default_cfg).arg(&bad_block);
-        let (yam_bad_code, yam_bad_msg) = capture_with_env(yam_bad, scenario.envs);
-
-        assert_eq!(ryl_bad_code, 1, "ryl bad exit ({})", scenario.label);
-        assert_eq!(yam_bad_code, 1, "yamllint bad exit ({})", scenario.label);
-        assert_eq!(
-            ryl_bad_msg, yam_bad_msg,
-            "bad block diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // good block should be clean
-        let mut ryl_good = build_ryl_command(exe, scenario.ryl_format);
-        ryl_good.arg("-c").arg(&default_cfg).arg(&good_block);
-        let (ryl_good_code, ryl_good_msg) = capture_with_env(ryl_good, scenario.envs);
-
-        let mut yam_good = build_yamllint_command(scenario.yam_format);
-        yam_good.arg("-c").arg(&default_cfg).arg(&good_block);
-        let (yam_good_code, yam_good_msg) = capture_with_env(yam_good, scenario.envs);
-
-        assert_eq!(ryl_good_code, 0, "ryl good exit ({})", scenario.label);
-        assert_eq!(yam_good_code, 0, "yamllint good exit ({})", scenario.label);
-        assert_eq!(
-            ryl_good_msg, yam_good_msg,
-            "good block diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // ignored-keys configuration should allow ignored patterns and flag others equally
-        let mut ryl_ignored = build_ryl_command(exe, scenario.ryl_format);
-        ryl_ignored.arg("-c").arg(&ignored_cfg).arg(&ignored_file);
-        let (ryl_ignored_code, ryl_ignored_msg) =
-            capture_with_env(ryl_ignored, scenario.envs);
-
-        let mut yam_ignored = build_yamllint_command(scenario.yam_format);
-        yam_ignored.arg("-c").arg(&ignored_cfg).arg(&ignored_file);
-        let (yam_ignored_code, yam_ignored_msg) =
-            capture_with_env(yam_ignored, scenario.envs);
-
-        assert_eq!(ryl_ignored_code, 1, "ryl ignored exit ({})", scenario.label);
-        assert_eq!(
-            yam_ignored_code, 1,
-            "yamllint ignored exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_ignored_msg, yam_ignored_msg,
-            "ignored diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        if skip_locale {
-            continue;
-        }
-
-        let mut ryl_locale = build_ryl_command(exe, scenario.ryl_format);
-        ryl_locale.arg("-c").arg(&locale_cfg).arg(&locale_file);
-        let (ryl_locale_code, ryl_locale_msg) =
-            capture_with_env(ryl_locale, scenario.envs);
-
-        let mut yam_locale = build_yamllint_command(scenario.yam_format);
-        yam_locale.arg("-c").arg(&locale_cfg).arg(&locale_file);
-        let (yam_locale_code, yam_locale_msg) =
-            capture_with_env(yam_locale, scenario.envs);
-
-        assert_eq!(ryl_locale_code, 0, "ryl locale exit ({})", scenario.label);
-        assert_eq!(
-            yam_locale_code, 0,
-            "yamllint locale exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_locale_msg, yam_locale_msg,
-            "locale diagnostics mismatch ({})",
-            scenario.label
-        );
-    }
-}

package/tests/yamllint_compat_line_length.rs

@@ -1,375 +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 line_length_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let default_cfg = dir.path().join("line-default.yml");
-    fs::write(
-        &default_cfg,
-        "rules:\n  document-start: disable\n  empty-lines: disable\n  new-line-at-end-of-file: disable\n  line-length:\n    max: 80\n",
-    )
-    .unwrap();
-
-    let warning_cfg = dir.path().join("line-warning.yml");
-    fs::write(
-        &warning_cfg,
-        "rules:\n  document-start: disable\n  empty-lines: disable\n  new-line-at-end-of-file: disable\n  line-length:\n    max: 80\n    level: warning\n",
-    )
-    .unwrap();
-
-    let strict_cfg = dir.path().join("line-strict.yml");
-    fs::write(
-        &strict_cfg,
-        "rules:\n  document-start: disable\n  line-length:\n    max: 20\n    allow-non-breakable-words: false\n",
-    )
-    .unwrap();
-
-    let inline_cfg = dir.path().join("line-inline.yml");
-    fs::write(
-        &inline_cfg,
-        "rules:\n  document-start: disable\n  line-length:\n    max: 20\n    allow-non-breakable-inline-mappings: true\n",
-    )
-    .unwrap();
-
-    let bad_file = dir.path().join("bad.yaml");
-    fs::write(
-        &bad_file,
-        "key: this line is definitely longer than eighty characters so yamllint and ryl should both flag it\n",
-    )
-    .unwrap();
-
-    let long_word_file = dir.path().join("long_word.yaml");
-    fs::write(&long_word_file, format!("{}\n", "A".repeat(50))).unwrap();
-
-    let inline_ok_file = dir.path().join("inline_ok.yaml");
-    fs::write(
-        &inline_ok_file,
-        "url: http://example.com/very/very/very/very/very/very/long/path\n",
-    )
-    .unwrap();
-
-    let inline_bad_file = dir.path().join("inline_bad.yaml");
-    fs::write(
-        &inline_bad_file,
-        "url: http://example.com/short + extra words to trigger the rule\n",
-    )
-    .unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        // default configuration should produce an error for spaced text
-        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
-        );
-
-        // strict configuration should flag long non-breakable words
-        let mut ryl_strict = build_ryl_command(exe, scenario.ryl_format);
-        ryl_strict.arg("-c").arg(&strict_cfg).arg(&long_word_file);
-        let (ryl_strict_code, ryl_strict_output) =
-            capture_with_env(ryl_strict, scenario.envs);
-
-        let mut yam_strict = build_yamllint_command(scenario.yam_format);
-        yam_strict.arg("-c").arg(&strict_cfg).arg(&long_word_file);
-        let (yam_strict_code, yam_strict_output) =
-            capture_with_env(yam_strict, scenario.envs);
-
-        assert_eq!(ryl_strict_code, 1, "ryl strict exit ({})", scenario.label);
-        assert_eq!(
-            yam_strict_code, 1,
-            "yamllint strict exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_strict_output, yam_strict_output,
-            "strict diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // inline mapping allowance should let long URLs through
-        let mut ryl_inline_ok = build_ryl_command(exe, scenario.ryl_format);
-        ryl_inline_ok
-            .arg("-c")
-            .arg(&inline_cfg)
-            .arg(&inline_ok_file);
-        let (ryl_inline_code, ryl_inline_output) =
-            capture_with_env(ryl_inline_ok, scenario.envs);
-
-        let mut yam_inline_ok = build_yamllint_command(scenario.yam_format);
-        yam_inline_ok
-            .arg("-c")
-            .arg(&inline_cfg)
-            .arg(&inline_ok_file);
-        let (yam_inline_code, yam_inline_output) =
-            capture_with_env(yam_inline_ok, scenario.envs);
-
-        assert_eq!(
-            ryl_inline_code, 0,
-            "ryl inline-ok exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_inline_code, 0,
-            "yamllint inline-ok exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_inline_output, yam_inline_output,
-            "inline ok diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // inline mapping option should still flag when spaces remain
-        let mut ryl_inline_bad = build_ryl_command(exe, scenario.ryl_format);
-        ryl_inline_bad
-            .arg("-c")
-            .arg(&inline_cfg)
-            .arg(&inline_bad_file);
-        let (ryl_inline_bad_code, ryl_inline_bad_output) =
-            capture_with_env(ryl_inline_bad, scenario.envs);
-
-        let mut yam_inline_bad = build_yamllint_command(scenario.yam_format);
-        yam_inline_bad
-            .arg("-c")
-            .arg(&inline_cfg)
-            .arg(&inline_bad_file);
-        let (yam_inline_bad_code, yam_inline_bad_output) =
-            capture_with_env(yam_inline_bad, scenario.envs);
-
-        assert_eq!(
-            ryl_inline_bad_code, 1,
-            "ryl inline-bad exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_inline_bad_code, 1,
-            "yamllint inline-bad exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_inline_bad_output, yam_inline_bad_output,
-            "inline bad diagnostics mismatch ({})",
-            scenario.label
-        );
-    }
-}
-
-#[test]
-fn line_length_disable_enable_comments_match_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-    let cfg = dir.path().join("line-110.yml");
-    fs::write(
-        &cfg,
-        "extends: default\nrules:\n  line-length:\n    max: 110\n",
-    )
-    .unwrap();
-
-    let input = dir.path().join("line-disable-comments.yaml");
-    fs::write(
-        &input,
-        "# yamllint disable rule:line-length\nmsg: \"This is a very very very very very very very very very very very very very very very long line that should be ignored\"\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 line-length disable comments ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_msg, yam_msg,
-            "diagnostics mismatch for line-length disable comments ({})",
-            scenario.label
-        );
-    }
-}
-
-#[test]
-fn line_length_disable_line_applies_to_one_line_only() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-    let cfg = dir.path().join("line-40.yml");
-    fs::write(
-        &cfg,
-        "extends: default\nrules:\n  line-length:\n    max: 40\n",
-    )
-    .unwrap();
-
-    let input = dir.path().join("line-disable-line.yaml");
-    fs::write(
-        &input,
-        "---\n# yamllint disable-line rule:line-length\nlong: \"01234567890123456789012345678901234567890123456789\"\nlong2: \"01234567890123456789012345678901234567890123456789\"\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 line-length disable-line semantics ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_msg, yam_msg,
-            "diagnostics mismatch for line-length disable-line semantics ({})",
-            scenario.label
-        );
-    }
-}
-
-#[test]
-fn line_length_disable_line_is_consumed_by_next_directive_line() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-    let cfg = dir.path().join("line-40.yml");
-    fs::write(
-        &cfg,
-        "extends: default\nrules:\n  line-length:\n    max: 40\n",
-    )
-    .unwrap();
-
-    let input = dir.path().join("line-disable-line-directive.yaml");
-    fs::write(
-        &input,
-        "---\n# yamllint disable-line rule:line-length\n# yamllint enable rule:line-length\nlong: \"01234567890123456789012345678901234567890123456789\"\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 disable-line consumed by directive line ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_msg, yam_msg,
-            "diagnostics mismatch for disable-line consumed by directive line ({})",
-            scenario.label
-        );
-    }
-}
-
-#[test]
-fn line_length_disable_line_is_consumed_by_blank_line() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-    let cfg = dir.path().join("line-40.yml");
-    fs::write(
-        &cfg,
-        "extends: default\nrules:\n  line-length:\n    max: 40\n",
-    )
-    .unwrap();
-
-    let input = dir.path().join("line-disable-line-blank.yaml");
-    fs::write(
-        &input,
-        "---\n# yamllint disable-line rule:line-length\n\nlong: \"01234567890123456789012345678901234567890123456789\"\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 disable-line consumed by blank line ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_msg, yam_msg,
-            "diagnostics mismatch for disable-line consumed by blank line ({})",
-            scenario.label
-        );
-    }
-}