add the interfaces of some coreutils for testing

tests/coreutils.rs

@@ -0,0 +1,17 @@
+#[path = "coreutils/arch.rs"]
+mod arch;
+
+#[path = "coreutils/b2sum.rs"]
+mod b2sum;
+
+#[path = "coreutils/base32.rs"]
+mod base32;
+
+#[path = "coreutils/basename.rs"]
+mod basename;
+
+#[path = "coreutils/cat.rs"]
+mod cat;
+
+#[path = "coreutils/mktemp.rs"]
+mod mktemp;

tests/coreutils/arch.rs

@@ -0,0 +1,22 @@
+use uutils_args::{Arguments, Options};
+
+#[derive(Clone, Arguments)]
+#[help("--help")]
+#[version("--version")]
+enum Arg {}
+
+#[derive(Default, Options)]
+#[arg_type(Arg)]
+struct Settings {}
+
+#[test]
+fn no_args() {
+    assert!(Settings::parse(["arch"]).is_ok());
+}
+
+#[test]
+fn one_arg_fails() {
+    assert!(Settings::parse(["arch", "-f"]).is_err());
+    assert!(Settings::parse(["arch", "--foo"]).is_err());
+    assert!(Settings::parse(["arch", "foo"]).is_err());
+}

tests/coreutils/b2sum.rs

@@ -0,0 +1,146 @@
+use std::path::{PathBuf, Path};
+
+use uutils_args::{Arguments, Options};
+
+#[derive(Clone, Arguments)]
+#[help("--help")]
+#[version("--version")]
+enum Arg {
+    #[option("-b", "--binary")]
+    Binary,
+
+    #[option("-c", "--check")]
+    Check,
+
+    #[option("--tag")]
+    Tag,
+
+    #[option("-t", "--text")]
+    Text,
+
+    #[option("-q", "--quiet")]
+    Quiet,
+
+    #[option("-s", "--status")]
+    Status,
+
+    #[option("--strict")]
+    Strict,
+
+    #[option("-w", "--warn")]
+    Warn,
+
+    #[positional(..)]
+    File(PathBuf),
+}
+
+#[derive(Default, Debug, PartialEq, Eq)]
+enum CheckOutput {
+    #[default]
+    Warn,
+    Quiet,
+    Status,
+}
+
+#[derive(Default, Options)]
+#[arg_type(Arg)]
+struct Settings {
+    #[map(
+        Arg::Binary => true,
+        Arg::Text => false,
+    )]
+    binary: bool,
+
+    #[map(Arg::Check => true)]
+    check: bool,
+
+    #[map(Arg::Tag => true)]
+    tag: bool,
+
+    #[map(
+        Arg::Warn => CheckOutput::Warn,
+        Arg::Quiet => CheckOutput::Quiet,
+        Arg::Status => CheckOutput::Status,
+    )]
+    check_output: CheckOutput,
+
+    #[map(Arg::Strict => true)]
+    strict: bool,
+
+    #[collect(set(Arg::File))]
+    files: Vec<PathBuf>,
+}
+
+#[test]
+fn binary() {
+    assert!(!Settings::parse(["b2sum"]).unwrap().binary);
+    assert!(!Settings::parse(["b2sum", "--text"]).unwrap().binary);
+    assert!(!Settings::parse(["b2sum", "-t"]).unwrap().binary);
+    assert!(
+        !Settings::parse(["b2sum", "--binary", "--text"])
+            .unwrap()
+            .binary
+    );
+    assert!(!Settings::parse(["b2sum", "-b", "-t"]).unwrap().binary);
+
+    assert!(Settings::parse(["b2sum", "--binary"]).unwrap().binary);
+    assert!(Settings::parse(["b2sum", "-b"]).unwrap().binary);
+    assert!(
+        Settings::parse(["b2sum", "--text", "--binary"])
+            .unwrap()
+            .binary
+    );
+    assert!(Settings::parse(["b2sum", "-t", "-b"]).unwrap().binary);
+}
+
+#[test]
+fn check_output() {
+    assert_eq!(
+        Settings::parse(["b2sum", "--warn"]).unwrap().check_output,
+        CheckOutput::Warn
+    );
+    assert_eq!(
+        Settings::parse(["b2sum", "--quiet"]).unwrap().check_output,
+        CheckOutput::Quiet
+    );
+    assert_eq!(
+        Settings::parse(["b2sum", "--status"]).unwrap().check_output,
+        CheckOutput::Status
+    );
+    assert_eq!(
+        Settings::parse(["b2sum", "--status", "--warn"])
+            .unwrap()
+            .check_output,
+        CheckOutput::Warn
+    );
+    assert_eq!(
+        Settings::parse(["b2sum", "--status", "--warn"])
+            .unwrap()
+            .check_output,
+        CheckOutput::Warn
+    );
+
+    assert_eq!(
+        Settings::parse(["b2sum", "--warn", "--quiet"])
+            .unwrap()
+            .check_output,
+        CheckOutput::Quiet
+    );
+
+    assert_eq!(
+        Settings::parse(["b2sum", "--quiet", "--status"])
+            .unwrap()
+            .check_output,
+        CheckOutput::Status
+    );
+}
+
+#[test]
+fn files() {
+    assert_eq!(
+        Settings::parse(["b2sum", "foo", "bar"])
+            .unwrap()
+            .files,
+        vec![Path::new("foo"), Path::new("bar")]
+    );
+}

tests/coreutils/base32.rs

@@ -0,0 +1,58 @@
+use std::path::PathBuf;
+
+use uutils_args::{Arguments, Options};
+
+#[derive(Clone, Arguments)]
+#[help("--help")]
+#[version("--version")]
+enum Arg {
+    #[option("-d", "--decode")]
+    Decode,
+
+    #[option("-i", "--ignore-garbage")]
+    IgnoreGarbage,
+
+    #[option("-w COLS", "--wrap=COLS")]
+    Wrap(usize),
+
+    #[positional(..=1)]
+    File(PathBuf),
+}
+
+#[derive(Options)]
+#[arg_type(Arg)]
+struct Settings {
+    #[map(Arg::Decode => true)]
+    decode: bool,
+
+    #[map(Arg::IgnoreGarbage => true)]
+    ignore_garbage: bool,
+
+    #[map(
+        Arg::Wrap(0) => None,
+        Arg::Wrap(n) => Some(n),
+    )]
+    wrap: Option<usize>,
+
+    #[map(Arg::File(f) => Some(f))]
+    file: Option<PathBuf>,
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            decode: false,
+            ignore_garbage: false,
+            wrap: Some(76),
+            file: None,
+        }
+    }
+}
+
+#[test]
+fn wrap() {
+    assert_eq!(Settings::parse(["base32"]).unwrap().wrap, Some(76));
+    assert_eq!(Settings::parse(["base32", "-w0"]).unwrap().wrap, None);
+    assert_eq!(Settings::parse(["base32", "-w100"]).unwrap().wrap, Some(100));
+    assert_eq!(Settings::parse(["base32", "--wrap=100"]).unwrap().wrap, Some(100));
+}

tests/coreutils/basename.rs

@@ -0,0 +1,77 @@
+use uutils_args::{Arguments, Options};
+
+#[derive(Clone, Arguments)]
+#[help("--help")]
+#[version("--version")]
+enum Arg {
+    #[option("-a", "--multiple")]
+    Multiple,
+
+    #[option("-s SUFFIX", "--suffix=SUFFIX")]
+    Suffix(String),
+
+    #[option("-z", "--zero")]
+    Zero,
+
+    #[positional(last, ..)]
+    Names(Vec<String>),
+}
+
+#[derive(Default, Options)]
+#[arg_type(Arg)]
+struct Settings {
+    #[map(Arg::Multiple | Arg::Suffix(_) => true)]
+    multiple: bool,
+
+    #[set(Arg::Suffix)]
+    suffix: String,
+
+    #[map(Arg::Zero => true)]
+    zero: bool,
+
+    #[set(Arg::Names)]
+    names: Vec<String>,
+}
+
+fn parse(args: &'static [&'static str]) -> Result<Settings, uutils_args::Error> {
+    let mut settings = Settings::parse(args)?;
+    if !settings.multiple {
+        assert_eq!(settings.names.len(), 2);
+        settings.suffix = settings.names.pop().unwrap();
+    }
+    Ok(settings)
+}
+
+#[test]
+fn name_and_suffix() {
+    let settings = parse(&["basename", "foobar", "bar"]).unwrap();
+    assert_eq!(settings.zero, false);
+    assert_eq!(settings.names, vec!["foobar"]);
+    assert_eq!(settings.suffix, "bar");
+}
+
+#[test]
+fn zero_name_and_suffix() {
+    let settings = parse(&["basename", "-z", "foobar", "bar"]).unwrap();
+    assert_eq!(settings.zero, true);
+    assert_eq!(settings.names, vec!["foobar"]);
+    assert_eq!(settings.suffix, "bar");
+}
+
+#[test]
+fn all_and_names() {
+    let settings = parse(&["basename", "-a", "foobar", "bar"]).unwrap();
+    assert_eq!(settings.multiple, true);
+    assert_eq!(settings.zero, false);
+    assert_eq!(settings.names, vec!["foobar", "bar"]);
+    assert_eq!(settings.suffix, "");
+}
+
+#[test]
+fn option_like_names() {
+    let settings = parse(&["basename", "-a", "--", "-a", "-z", "--suffix=SUFFIX"]).unwrap();
+    assert_eq!(settings.multiple, true);
+    assert_eq!(settings.zero, false);
+    assert_eq!(settings.names, vec!["-a", "-z", "--suffix=SUFFIX"]);
+    assert_eq!(settings.suffix, "");
+}

tests/coreutils/cat.rs

@@ -0,0 +1,104 @@
+use std::path::PathBuf;
+
+use uutils_args::{Arguments, Options};
+
+#[derive(Default)]
+enum NumberingMode {
+    #[default]
+    None,
+    NonEmpty,
+    All,
+}
+
+#[derive(Clone, Arguments)]
+#[help("--help")]
+#[version("--version")]
+enum Arg {
+    #[option("-A", "--show-all")]
+    ShowAll,
+
+    #[option("-b", "--number-nonblank")]
+    NumberNonblank,
+
+    #[option("-e")]
+    ShowNonPrintingEnds,
+
+    #[option("-E")]
+    ShowEnds,
+
+    #[option("-n", "--number")]
+    Number,
+
+    #[option("-s", "--squeeze-blank")]
+    SqueezeBlank,
+
+    #[option("-t")]
+    ShowNonPrintingTabs,
+
+    #[option("-T", "--show-tabs")]
+    ShowTabs,
+
+    #[option("-v", "--show-nonprinting")]
+    ShowNonPrinting,
+
+    #[positional(..)]
+    File(PathBuf),
+}
+
+#[derive(Default, Options)]
+#[arg_type(Arg)]
+struct Settings {
+    #[map(Arg::ShowAll | Arg::ShowTabs | Arg::ShowNonPrintingTabs => true)]
+    show_tabs: bool,
+
+    #[map(Arg::ShowAll | Arg::ShowEnds | Arg::ShowNonPrintingEnds => true)]
+    show_ends: bool,
+
+    #[map(
+        Arg::ShowAll
+        | Arg::ShowNonPrintingEnds
+        | Arg::ShowNonPrintingTabs
+        | Arg::ShowNonPrinting
+            => true
+    )]
+    show_nonprinting: bool,
+
+    #[map(
+        Arg::Number => NumberingMode::All,
+        Arg::NumberNonblank => NumberingMode::NonEmpty,
+    )]
+    number: NumberingMode,
+
+    #[map(Arg::SqueezeBlank => true)]
+    squeeze_blank: bool,
+
+    #[collect(set(Arg::File))]
+    files: Vec<PathBuf>,
+}
+
+#[test]
+fn show() {
+    let s = Settings::parse(["cat", "-v"]).unwrap();
+    assert!(!s.show_ends && !s.show_tabs && s.show_nonprinting);
+
+    let s = Settings::parse(["cat", "-E"]).unwrap();
+    assert!(s.show_ends && !s.show_tabs && !s.show_nonprinting);
+
+    let s = Settings::parse(["cat", "-T"]).unwrap();
+    assert!(!s.show_ends && s.show_tabs && !s.show_nonprinting);
+
+    let s = Settings::parse(["cat", "-e"]).unwrap();
+    assert!(s.show_ends && !s.show_tabs && s.show_nonprinting);
+
+    let s = Settings::parse(["cat", "-t"]).unwrap();
+    assert!(!s.show_ends && s.show_tabs && s.show_nonprinting);
+
+    let s = Settings::parse(["cat", "-A"]).unwrap();
+    assert!(s.show_ends && s.show_tabs && s.show_nonprinting);
+    
+    let s = Settings::parse(["cat", "-te"]).unwrap();
+    assert!(s.show_ends && s.show_tabs && s.show_nonprinting);
+    
+    let s = Settings::parse(["cat", "-vET"]).unwrap();
+    assert!(s.show_ends && s.show_tabs && s.show_nonprinting);
+}

tests/coreutils/mktemp.rs

@@ -0,0 +1,54 @@
+use uutils_args::{Arguments, Options};
+
+#[derive(Clone, Arguments)]
+#[help("--help")]
+#[version("--version")]
+enum Arg {
+    #[option("-d", "--directory")]
+    Directory,
+
+    #[option("-u", "--dry-run")]
+    DryRun,
+
+    #[option("-q", "--quiet")]
+    Quiet,
+
+    #[option("--suffix")]
+    Suffix(String),
+
+    #[option("-t")]
+    TreatAsTemplate,
+
+    #[option("-p", "--tmpdir")]
+    TmpDir(Option<String>),
+
+    #[positional(0..=1)]
+    Template(String),
+}
+
+#[derive(Default, Options)]
+#[arg_type(Arg)]
+struct Settings {
+    #[map(Arg::Directory => true)]
+    directory: bool,
+
+    #[map(Arg::DryRun => true)]
+    dry_run: bool,
+
+    #[map(Arg::Quiet => true)]
+    quiet: bool,
+
+    #[map(Arg::Suffix(s) => Some(s))]
+    suffix: Option<String>,
+
+    #[map(Arg::TreatAsTemplate => true)]
+    treat_as_template: bool,
+
+    #[set(Arg::Template)]
+    template: String,
+}
+
+#[test]
+fn test() {
+    assert!(true);
+}