forjar 1.4.2

//! Tests: Coverage for remaining args structs (lock_core_args, lock_ops_args, misc_args, misc_ops_args, plan_args, state_args, commands/mod.rs).

use super::commands::*;
use std::path::PathBuf;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_cov_lock_history_args_construct() {
        let a = LockHistoryArgs {
            state_dir: PathBuf::from("s"),
            json: true,
            limit: 20,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_lock_integrity_args_construct() {
        let a = LockIntegrityArgs {
            state_dir: PathBuf::from("s"),
            json: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_lock_rehash_args_construct() {
        let a = LockRehashArgs {
            state_dir: PathBuf::from("s"),
            json: true,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_lock_restore_args_construct() {
        let a = LockRestoreArgs {
            state_dir: PathBuf::from("s"),
            name: Some("snap1".to_string()),
            json: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_lock_verify_schema_args_construct() {
        let a = LockVerifySchemaArgs {
            state_dir: PathBuf::from("s"),
            json: true,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_lock_tag_args_construct() {
        let a = LockTagArgs {
            state_dir: PathBuf::from("s"),
            name: "env".to_string(),
            value: "prod".to_string(),
            json: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_lock_migrate_args_construct() {
        let a = LockMigrateArgs {
            state_dir: PathBuf::from("s"),
            from_version: "1.0".to_string(),
            json: false,
        };
        let _ = format!("{a:?}");
    }

    // ── misc_args.rs (47 uncov) ──

    #[test]
    fn test_cov_init_args_construct() {
        let a = InitArgs {
            path: PathBuf::from("."),
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_drift_args_construct() {
        let a = DriftArgs {
            file: PathBuf::from("f.yaml"),
            machine: None,
            state_dir: PathBuf::from("s"),
            tripwire: false,
            alert_cmd: None,
            auto_remediate: false,
            dry_run: false,
            json: false,
            env_file: None,
            workspace: None,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_history_args_construct() {
        let a = HistoryArgs {
            state_dir: PathBuf::from("s"),
            machine: None,
            limit: 10,
            json: false,
            since: None,
            resource: None,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_destroy_args_construct() {
        let a = DestroyArgs {
            file: PathBuf::from("f.yaml"),
            machine: None,
            yes: false,
            state_dir: PathBuf::from("s"),
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_import_args_construct() {
        let a = ImportArgs {
            addr: "localhost".to_string(),
            user: "root".to_string(),
            name: None,
            output: PathBuf::from("f.yaml"),
            scan: vec!["packages".to_string()],
            smart: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_show_args_construct() {
        let a = ShowArgs {
            file: PathBuf::from("f.yaml"),
            resource: None,
            json: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_check_args_construct() {
        let a = CheckArgs {
            file: PathBuf::from("f.yaml"),
            machine: None,
            resource: None,
            tag: None,
            json: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_diff_args_construct() {
        let a = DiffArgs {
            from: PathBuf::from("a"),
            to: PathBuf::from("b"),
            machine: None,
            resource: None,
            json: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_fmt_args_construct() {
        let a = FmtArgs {
            file: PathBuf::from("f.yaml"),
            check: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_lint_args_construct() {
        let a = LintArgs {
            file: PathBuf::from("f.yaml"),
            json: false,
            strict: false,
            fix: false,
            rules: None,
            bashrs_version: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_rollback_args_construct() {
        let a = RollbackArgs {
            file: PathBuf::from("f.yaml"),
            revision: 1,
            generation: None,
            machine: None,
            dry_run: false,
            yes: false,
            state_dir: PathBuf::from("s"),
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_anomaly_args_construct() {
        let a = AnomalyArgs {
            state_dir: PathBuf::from("s"),
            machine: None,
            min_events: 3,
            json: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_trace_args_construct() {
        let a = TraceArgs {
            state_dir: PathBuf::from("s"),
            machine: None,
            json: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_migrate_args_construct() {
        let a = MigrateArgs {
            file: PathBuf::from("f.yaml"),
            output: None,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_mcp_args_construct() {
        let a = McpArgs { schema: false };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_bench_args_construct() {
        let a = BenchArgs {
            iterations: 1000,
            json: false,
            compare: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_output_args_construct() {
        let a = OutputArgs {
            file: PathBuf::from("f.yaml"),
            key: None,
            json: false,
        };
        let _ = format!("{a:?}");
    }

    #[test]
    fn test_cov_policy_args_construct() {
        let a = PolicyArgs {
            file: PathBuf::from("f.yaml"),
            json: false,
            sarif: false,
        };
        let _ = format!("{a:?}");
    }
}