test: cover GNU dangling symlink cases

Add seven ls tests mirroring GNU tests/ls/ls-misc.pl
sl-dangle3..9 to validate combinations of `ln=`, `or=` and `mi=`
settings. The tests verify both file-level output and directory
listings, including the `\x1b[m` reset requirement when `or=:` is
set.

Author: karanabe

tests/by-util/test_ls.rs

@@ -3,7 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 // spell-checker:ignore (words) READMECAREFULLY birthtime doesntexist oneline somebackup lrwx somefile somegroup somehiddenbackup somehiddenfile tabsize aaaaaaaa bbbb cccc dddddddd ncccc neee naaaaa nbcdef nfffff dired subdired tmpfs mdir COLORTERM mexe bcdef mfoo timefile
-// spell-checker:ignore (words) fakeroot setcap drwxr bcdlps
+// spell-checker:ignore (words) fakeroot setcap drwxr bcdlps mdangling mentry
 #![allow(
     clippy::similar_names,
     clippy::too_many_lines,
@@ -1446,31 +1446,213 @@ fn test_ls_long_dangling_symlink_color() {
 
     at.mkdir("dir1");
     at.symlink_dir("foo", "dir1/dangling_symlink");
+    let ls_colors = "ln=target:or=40:mi=34";
     let result = ts
         .ucmd()
+        .env("LS_COLORS", ls_colors)
         .arg("-l")
         .arg("--color=always")
         .arg("dir1/dangling_symlink")
         .succeeds();
 
     let stdout = result.stdout_str();
-    // stdout contains output like in the below sequence. We match for the color i.e. 01;36
-    // \x1b[0m\x1b[01;36mdir1/dangling_symlink\x1b[0m -> \x1b[01;36mfoo\x1b[0m
-    let color_regex = Regex::new(r"(\d\d;)\d\dm").unwrap();
-    // colors_vec[0] contains the symlink color and style and colors_vec[1] contains the color and style of the file the
-    // symlink points to.
-    let colors_vec: Vec<_> = color_regex
-        .find_iter(stdout)
-        .map(|color| color.as_str())
-        .collect();
+    // Ensure dangling link name uses `or=` and target uses `mi=`.
+    let name_regex =
+        Regex::new(r"(?:\x1b\[[0-9;]*m)*\x1b\[([0-9;]*)mdir1/dangling_symlink\x1b\[0m").unwrap();
+    let target_path = regex::escape(&at.plus_as_string("foo"));
+    let target_pattern = format!(r"(?:\x1b\[[0-9;]*m)*\x1b\[([0-9;]*)m{target_path}\x1b\[0m");
+    let target_regex = Regex::new(&target_pattern).unwrap();
+
+    let name_caps = name_regex
+        .captures(stdout)
+        .expect("failed to capture dangling symlink name color");
+    let target_caps = target_regex
+        .captures(stdout)
+        .expect("failed to capture dangling target color");
+
+    let name_color = name_caps.get(1).unwrap().as_str();
+    let target_color = target_caps.get(1).unwrap().as_str();
+
+    assert_eq!(name_color, "40");
+    assert_eq!(target_color, "34");
+}
+
+#[test]
+/// Mirrors GNU `tests/ls/ls-misc.pl::sl-dangle3`.
+fn test_ls_dangling_symlink_or_and_missing_colors() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.symlink_file("nowhere", "dangling");
+
+    let stdout = ts
+        .ucmd()
+        .env("LS_COLORS", "ln=target:or=40:mi=34")
+        .arg("-o")
+        .arg("--time-style=+:TIME:")
+        .arg("--color=always")
+        .arg("dangling")
+        .succeeds()
+        .stdout_str()
+        .to_string();
 
-    assert_eq!(colors_vec[0], colors_vec[1]);
-    // constructs the string of file path with the color code
-    let symlink_color_name = colors_vec[0].to_owned() + "dir1/dangling_symlink\x1b";
-    let target_color_name = colors_vec[1].to_owned() + at.plus_as_string("foo\x1b").as_str();
+    let color_regex = Regex::new(
+        r"\x1b\[0m\x1b\[(?P<link>[0-9;]*)mdangling\x1b\[0m -> \x1b\[(?P<target>[0-9;]*)m",
+    )
+    .unwrap();
+    let captures = color_regex
+        .captures(&stdout)
+        .expect("failed to capture dangling colors");
 
-    assert!(stdout.contains(&symlink_color_name));
-    assert!(stdout.contains(&target_color_name));
+    assert_eq!(captures.name("link").unwrap().as_str(), "40");
+    assert_eq!(captures.name("target").unwrap().as_str(), "34");
+}
+
+#[test]
+/// Mirrors GNU `tests/ls/ls-misc.pl::sl-dangle4`.
+fn test_ls_dangling_symlink_ln_or_priority() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.symlink_file("nowhere", "dangling");
+
+    let stdout = ts
+        .ucmd()
+        .env("LS_COLORS", "ln=34:mi=35:or=36")
+        .arg("-o")
+        .arg("--time-style=+:TIME:")
+        .arg("--color=always")
+        .arg("dangling")
+        .succeeds()
+        .stdout_str()
+        .to_string();
+
+    let color_regex = Regex::new(
+        r"\x1b\[0m\x1b\[(?P<link>[0-9;]*)mdangling\x1b\[0m -> \x1b\[(?P<target>[0-9;]*)m",
+    )
+    .unwrap();
+    let captures = color_regex
+        .captures(&stdout)
+        .expect("failed to capture dangling colors");
+    assert_eq!(captures.name("link").unwrap().as_str(), "36");
+    assert_eq!(captures.name("target").unwrap().as_str(), "35");
+}
+
+#[test]
+/// Mirrors GNU `tests/ls/ls-misc.pl::sl-dangle5`.
+fn test_ls_dangling_symlink_ln_and_missing_colors() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.symlink_file("nowhere", "dangling");
+
+    let stdout = ts
+        .ucmd()
+        .env("LS_COLORS", "ln=34:mi=35")
+        .arg("-o")
+        .arg("--time-style=+:TIME:")
+        .arg("--color=always")
+        .arg("dangling")
+        .succeeds()
+        .stdout_str()
+        .to_string();
+
+    let color_regex = Regex::new(
+        r"\x1b\[0m\x1b\[(?P<link>[0-9;]*)mdangling\x1b\[0m -> \x1b\[(?P<target>[0-9;]*)m",
+    )
+    .unwrap();
+    let captures = color_regex
+        .captures(&stdout)
+        .expect("failed to capture dangling colors");
+    assert_eq!(captures.name("link").unwrap().as_str(), "34");
+    assert_eq!(captures.name("target").unwrap().as_str(), "35");
+}
+
+#[test]
+/// Mirrors GNU `tests/ls/ls-misc.pl::sl-dangle7`.
+fn test_ls_dangling_symlink_blank_or_still_emits_reset() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.symlink_file("nowhere", "dangling");
+
+    let stdout = ts
+        .ucmd()
+        .env("LS_COLORS", "ln=target:or=:ex=:")
+        .arg("--color=always")
+        .arg("dangling")
+        .succeeds()
+        .stdout_str()
+        .to_string();
+
+    assert!(
+        stdout.contains("\u{1b}[0m\u{1b}[mdangling\u{1b}[0m"),
+        "unexpected output: {stdout:?}"
+    );
+}
+
+#[test]
+/// Mirrors GNU `tests/ls/ls-misc.pl::sl-dangle9`.
+fn test_ls_dangling_symlink_blank_or_in_directory_listing() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.mkdir("dir");
+    at.symlink_file("nowhere", "dir/entry");
+
+    let stdout = ts
+        .ucmd()
+        .env("LS_COLORS", "ln=target:or=:ex=:")
+        .arg("--color=always")
+        .arg("dir")
+        .succeeds()
+        .stdout_str()
+        .to_string();
+
+    assert!(
+        stdout.contains("\u{1b}[0m\u{1b}[mentry\u{1b}[0m"),
+        "unexpected output: {stdout:?}"
+    );
+}
+
+#[test]
+/// Mirrors GNU `tests/ls/ls-misc.pl::sl-dangle8`.
+fn test_ls_dangling_symlink_uses_ln_when_or_blank() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.symlink_file("nowhere", "dangling");
+
+    let stdout = ts
+        .ucmd()
+        .env("LS_COLORS", "ln=1;36:or=:")
+        .arg("--color=always")
+        .arg("dangling")
+        .succeeds()
+        .stdout_str()
+        .to_string();
+
+    assert!(
+        stdout.contains("\u{1b}[0m\u{1b}[1;36mdangling\u{1b}[0m"),
+        "unexpected output: {stdout:?}"
+    );
+}
+
+#[test]
+/// Mirrors GNU `tests/ls/ls-misc.pl::sl-dangle6`.
+fn test_ls_directory_dangling_symlink_uses_ln_when_or_blank() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.mkdir("dir");
+    at.symlink_file("nowhere", "dir/entry");
+
+    let stdout = ts
+        .ucmd()
+        .env("LS_COLORS", "ln=1;36:or=:")
+        .arg("--color=always")
+        .arg("dir")
+        .succeeds()
+        .stdout_str()
+        .to_string();
+
+    assert!(
+        stdout.contains("\u{1b}[0m\u{1b}[1;36mentry\u{1b}[0m"),
+        "unexpected output: {stdout:?}"
+    );
 }
 
 #[test]
@@ -5862,8 +6044,7 @@ fn test_ls_color_norm() {
         .stdout_contains(expected);
 
     // uncolored ordinary files that do _not_ inherit from NORMAL.
-    let expected =
-        "\x1b[0m\x1b[07mnorm \x1b[0mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
+    let expected = "\x1b[0m\x1b[07mnorm \x1b[0m\x1b[mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
     scene
         .ucmd()
         .env("LS_COLORS", format!("{colors}:fi="))
@@ -5876,8 +6057,7 @@ fn test_ls_color_norm() {
         .stdout_str_apply(strip)
         .stdout_contains(expected);
 
-    let expected =
-        "\x1b[0m\x1b[07mnorm \x1b[0mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
+    let expected = "\x1b[0m\x1b[07mnorm \x1b[0m\x1b[00mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
     scene
         .ucmd()
         .env("LS_COLORS", format!("{colors}:fi=0"))
@@ -6498,7 +6678,7 @@ fn test_f_overrides_sort_flags() {
 
     // Create files with different sizes for predictable sort order
     at.write("small.txt", "a"); // 1 byte
-    at.write("medium.txt", "bb"); // 2 bytes  
+    at.write("medium.txt", "bb"); // 2 bytes
     at.write("large.txt", "ccc"); // 3 bytes
 
     // Get baseline outputs (include -a to match -f behavior which shows all files)