Move flag tests to separate module and clean up deref patterns

1 files changed, 1 insertions, 360 deletions

diff --git a/mingling_core/src/program/flag.rs b/mingling_core/src/program/flag.rs
index 0865414..6cf126d 100644
--- a/mingling_core/src/program/flag.rs
+++ b/mingling_core/src/program/flag.rs
@@ -160,366 +160,7 @@ macro_rules! special_arguments {
 }
 
 #[cfg(test)]
-mod tests {
-    use crate::Flag;
-
-    #[test]
-    fn test_special_flag() {
-        // Test flag found and removed
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "--help".to_string(),
-            "c".to_string(),
-        ];
-        let result = special_flag!(args, "--help");
-        assert!(result);
-        assert_eq!(args, vec!["a", "b", "c"]);
-
-        // Test flag found at beginning
-        let mut args = vec![
-            "--help".to_string(),
-            "a".to_string(),
-            "b".to_string(),
-            "c".to_string(),
-        ];
-        let result = special_flag!(args, "--help");
-        assert!(result);
-        assert_eq!(args, vec!["a", "b", "c"]);
-
-        // Test flag found at end
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "c".to_string(),
-            "--help".to_string(),
-        ];
-        let result = special_flag!(args, "--help");
-        assert!(result);
-        assert_eq!(args, vec!["a", "b", "c"]);
-
-        // Test flag not found
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "--other".to_string(),
-            "c".to_string(),
-        ];
-        let result = special_flag!(args, "--help");
-        assert!(!result);
-        assert_eq!(args, vec!["a", "b", "--other", "c"]);
-
-        // Test multiple same flags all removed
-        let mut args = vec![
-            "--help".to_string(),
-            "a".to_string(),
-            "--help".to_string(),
-            "b".to_string(),
-            "--help".to_string(),
-        ];
-        let result = special_flag!(args, "--help");
-        assert!(result);
-        assert_eq!(args, vec!["a", "b"]);
-
-        // Test empty args
-        let mut args: Vec<String> = Vec::new();
-        let result = special_flag!(args, "--help");
-        assert!(!result);
-        assert_eq!(args, Vec::<String>::new());
-
-        // Test flag with empty string
-        let mut args = vec!["a".to_string(), "".to_string(), "b".to_string()];
-        let result = special_flag!(args, "");
-        assert!(result);
-        assert_eq!(args, vec!["a", "b"]);
-
-        // Test flag with dash in middle
-        let mut args = vec!["a".to_string(), "test-flag".to_string(), "b".to_string()];
-        let result = special_flag!(args, "test-flag");
-        assert!(result);
-        assert_eq!(args, vec!["a", "b"]);
-
-        // Test flag that's a substring of another flag (should not match)
-        let mut args = vec!["a".to_string(), "--helpful".to_string(), "b".to_string()];
-        let result = special_flag!(args, "--help");
-        assert!(!result);
-        assert_eq!(args, vec!["a", "--helpful", "b"]);
-    }
-
-    #[test]
-    fn test_special_argument() {
-        // Test extracting value after flag
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "--file".to_string(),
-            "test.txt".to_string(),
-            "c".to_string(),
-        ];
-        let result = special_argument!(args, "--file");
-        assert_eq!(result, Some("test.txt".to_string()));
-        assert_eq!(args, vec!["a", "b", "c"]);
-
-        // Test extracting value when flag is at beginning
-        let mut args = vec![
-            "--file".to_string(),
-            "test.txt".to_string(),
-            "a".to_string(),
-            "b".to_string(),
-        ];
-        let result = special_argument!(args, "--file");
-        assert_eq!(result, Some("test.txt".to_string()));
-        assert_eq!(args, vec!["a", "b"]);
-
-        // Test extracting value when flag is at end
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "--file".to_string(),
-            "test.txt".to_string(),
-        ];
-        let result = special_argument!(args, "--file");
-        assert_eq!(result, Some("test.txt".to_string()));
-        assert_eq!(args, vec!["a", "b"]);
-
-        // Test flag without value (at end)
-        let mut args = vec!["a".to_string(), "b".to_string(), "--file".to_string()];
-        let result = special_argument!(args, "--file");
-        assert_eq!(result, None);
-        assert_eq!(args, vec!["a", "b"]);
-
-        // Test flag without value (not at end)
-        let mut args = vec!["a".to_string(), "--file".to_string(), "b".to_string()];
-        let result = special_argument!(args, "--file");
-        assert_eq!(result, Some("b".to_string()));
-        assert_eq!(args, vec!["a"]);
-
-        // Test flag not found
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "--other".to_string(),
-            "value".to_string(),
-        ];
-        let result = special_argument!(args, "--file");
-        assert_eq!(result, None);
-        assert_eq!(args, vec!["a", "b", "--other", "value"]);
-
-        // Test empty args
-        let mut args: Vec<String> = Vec::new();
-        let result = special_argument!(args, "--file");
-        assert_eq!(result, None);
-        assert_eq!(args, Vec::<String>::new());
-
-        // Test multiple same flags (should only extract first)
-        let mut args = vec![
-            "--file".to_string(),
-            "first.txt".to_string(),
-            "--file".to_string(),
-            "second.txt".to_string(),
-        ];
-        let result = special_argument!(args, "--file");
-        assert_eq!(result, Some("first.txt".to_string()));
-        assert_eq!(args, vec!["--file", "second.txt"]);
-
-        // Test flag with empty string value
-        let mut args = vec![
-            "a".to_string(),
-            "--file".to_string(),
-            "".to_string(),
-            "b".to_string(),
-        ];
-        let result = special_argument!(args, "--file");
-        assert_eq!(result, Some("".to_string()));
-        assert_eq!(args, vec!["a", "b"]);
-
-        // Test flag with value starting with dash
-        let mut args = vec![
-            "a".to_string(),
-            "--file".to_string(),
-            "-value".to_string(),
-            "b".to_string(),
-        ];
-        let result = special_argument!(args, "--file");
-        assert_eq!(result, Some("-value".to_string()));
-        assert_eq!(args, vec!["a", "b"]);
-    }
-
-    #[test]
-    fn test_special_arguments() {
-        // Test extracting multiple values after flag
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "--list".to_string(),
-            "a".to_string(),
-            "b".to_string(),
-            "c".to_string(),
-            "d".to_string(),
-            "--next".to_string(),
-            "1".to_string(),
-        ];
-        let result = special_arguments!(args, "--list");
-        assert_eq!(result, vec!["a", "b", "c", "d"]);
-        assert_eq!(args, vec!["a", "b", "--next", "1"]);
-
-        // Test extracting single value
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "--next".to_string(),
-            "1".to_string(),
-        ];
-        let result = special_arguments!(args, "--next");
-        assert_eq!(result, vec!["1"]);
-        assert_eq!(args, vec!["a", "b"]);
-
-        // Test extracting from beginning
-        let mut args = vec![
-            "--list".to_string(),
-            "a".to_string(),
-            "b".to_string(),
-            "--next".to_string(),
-            "1".to_string(),
-        ];
-        let result = special_arguments!(args, "--list");
-        assert_eq!(result, vec!["a", "b"]);
-        assert_eq!(args, vec!["--next", "1"]);
-
-        // Test extracting when no values after flag
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "--list".to_string(),
-            "--next".to_string(),
-            "1".to_string(),
-        ];
-        let result = special_arguments!(args, "--list");
-        assert_eq!(result, Vec::<String>::new());
-        assert_eq!(args, vec!["a", "b", "--next", "1"]);
-
-        // Test extracting when flag not found
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "--list".to_string(),
-            "c".to_string(),
-            "d".to_string(),
-        ];
-        let result = special_arguments!(args, "--none");
-        assert_eq!(result, Vec::<String>::new());
-        assert_eq!(args, vec!["a", "b", "--list", "c", "d"]);
-
-        // Test extracting empty args
-        let mut args: Vec<String> = Vec::new();
-        let result = special_arguments!(args, "--list");
-        assert_eq!(result, Vec::<String>::new());
-        assert_eq!(args, Vec::<String>::new());
-
-        // Test extracting with only flag at end
-        let mut args = vec!["--list".to_string()];
-        let result = special_arguments!(args, "--list");
-        assert_eq!(result, Vec::<String>::new());
-        assert_eq!(args, Vec::<String>::new());
-
-        // Test extracting multiple values until end of args
-        let mut args = vec![
-            "--list".to_string(),
-            "a".to_string(),
-            "b".to_string(),
-            "c".to_string(),
-        ];
-        let result = special_arguments!(args, "--list");
-        assert_eq!(result, vec!["a", "b", "c"]);
-        assert_eq!(args, Vec::<String>::new());
-
-        // Test extracting with mixed non-dash values
-        let mut args = vec![
-            "--list".to_string(),
-            "value1".to_string(),
-            "value2".to_string(),
-            "-next".to_string(),
-            "value3".to_string(),
-        ];
-        let result = special_arguments!(args, "--list");
-        assert_eq!(result, vec!["value1", "value2"]);
-        assert_eq!(args, vec!["-next", "value3"]);
-
-        // Test extracting with single dash values
-        let mut args = vec![
-            "--list".to_string(),
-            "-a".to_string(),
-            "-b".to_string(),
-            "--next".to_string(),
-            "1".to_string(),
-        ];
-        let result = special_arguments!(args, "--list");
-        assert_eq!(result, Vec::<String>::new());
-        assert_eq!(args, vec!["-a", "-b", "--next", "1"]);
-
-        // Test extracting with empty flag
-        let mut args = vec![
-            "a".to_string(),
-            "b".to_string(),
-            "--next".to_string(),
-            "1".to_string(),
-        ];
-        let result = special_arguments!(args, "");
-        assert_eq!(result, vec!["a", "b"]);
-        assert_eq!(args, vec!["--next", "1"]);
-    }
-
-    #[test]
-    fn test_flag_from_empty_tuple() {
-        let flag = Flag::from(());
-        assert_eq!(flag.as_ref(), &[] as &[&str]);
-    }
-
-    #[test]
-    fn test_flag_from_static_str() {
-        let flag = Flag::from("-h");
-        assert_eq!(flag.as_ref(), &["-h"]);
-    }
-
-    #[test]
-    fn test_flag_from_slice() {
-        let flag = Flag::from(&["-h", "--help"][..]);
-        assert_eq!(flag.as_ref(), &["-h", "--help"]);
-    }
-
-    #[test]
-    fn test_flag_from_array() {
-        let flag = Flag::from(["-v", "--verbose"]);
-        assert_eq!(flag.as_ref(), &["-v", "--verbose"]);
-    }
-
-    #[test]
-    fn test_flag_from_ref_array() {
-        let flag = Flag::from(&["-f", "--file"]);
-        assert_eq!(flag.as_ref(), &["-f", "--file"]);
-    }
-
-    #[test]
-    fn test_flag_from_ref_flag() {
-        let original = Flag::from("-x");
-        let cloned = Flag::from(&original);
-        assert_eq!(cloned.as_ref(), &["-x"]);
-    }
-
-    #[test]
-    fn test_flag_as_ref() {
-        let flag = Flag::from("-h");
-        let r: &[&str] = flag.as_ref();
-        assert_eq!(r, &["-h"]);
-    }
-
-    #[test]
-    fn test_flag_deref() {
-        let flag = Flag::from(["-a", "-b"]);
-        let collected: Vec<&&str> = flag.iter().collect();
-        assert_eq!(collected, vec![&"-a", &"-b"]);
-    }
-}
+mod tests;
 
 impl<C> Program<C>
 where