From a31f9bef3978604fb43bc1f612023936eef42ef2 Mon Sep 17 00:00:00 2001 From: Terts Diepraam Date: Fri, 22 Dec 2023 15:00:10 +0100 Subject: [PATCH] test the new positional argument system in coreutils tests --- tests/coreutils/base32.rs | 50 ++++++++++++++++++++----------------- tests/coreutils/basename.rs | 32 +++++++++++++++--------- tests/coreutils/ls.rs | 2 +- tests/coreutils/mktemp.rs | 47 +++++++++++++++++++++++----------- 4 files changed, 81 insertions(+), 50 deletions(-) diff --git a/tests/coreutils/base32.rs b/tests/coreutils/base32.rs index de32e74..24ce251 100644 --- a/tests/coreutils/base32.rs +++ b/tests/coreutils/base32.rs @@ -1,4 +1,9 @@ -use uutils_args::{Arguments, Options}; +use std::ffi::OsString; + +use uutils_args::{ + positional::{Opt, Unpack}, + Arguments, Options, +}; #[derive(Clone, Arguments)] enum Arg { @@ -39,30 +44,29 @@ impl Options for Settings { } } +fn parse(args: I) -> Result<(Settings, Option), uutils_args::Error> +where + I: IntoIterator, + I::Item: Into, +{ + let (s, ops) = Settings::default().parse(args)?; + let file = Opt("FILE").unpack(ops)?; + Ok((s, file)) +} + #[test] fn wrap() { + assert_eq!(parse(["base32"]).unwrap().0.wrap, Some(76)); + assert_eq!(parse(["base32", "-w0"]).unwrap().0.wrap, None); + assert_eq!(parse(["base32", "-w100"]).unwrap().0.wrap, Some(100)); + assert_eq!(parse(["base32", "--wrap=100"]).unwrap().0.wrap, Some(100)); +} + +#[test] +fn file() { + assert_eq!(parse(["base32"]).unwrap().1, None); assert_eq!( - Settings::default().parse(["base32"]).unwrap().0.wrap, - Some(76) - ); - assert_eq!( - Settings::default().parse(["base32", "-w0"]).unwrap().0.wrap, - None - ); - assert_eq!( - Settings::default() - .parse(["base32", "-w100"]) - .unwrap() - .0 - .wrap, - Some(100) - ); - assert_eq!( - Settings::default() - .parse(["base32", "--wrap=100"]) - .unwrap() - .0 - .wrap, - Some(100) + parse(["base32", "file"]).unwrap().1, + Some(OsString::from("file")) ); } diff --git a/tests/coreutils/basename.rs b/tests/coreutils/basename.rs index 7f0716e..9324fe3 100644 --- a/tests/coreutils/basename.rs +++ b/tests/coreutils/basename.rs @@ -1,6 +1,9 @@ use std::ffi::OsString; -use uutils_args::{Arguments, Options}; +use uutils_args::{ + positional::{Many1, Unpack}, + Arguments, Options, +}; #[derive(Clone, Arguments)] enum Arg { @@ -35,19 +38,24 @@ impl Options for Settings { } } -fn parse(args: &[&str]) -> Settings { - let (mut settings, operands) = Settings::default().parse(args).unwrap(); - settings.names = operands; - if !settings.multiple { - assert_eq!(settings.names.len(), 2); - settings.suffix = settings.names.pop().unwrap(); +fn parse(args: &[&str]) -> Result { + let (mut settings, operands) = Settings::default().parse(args)?; + + if settings.multiple { + let names = Many1("FILE").unpack(operands)?; + settings.names = names; + } else { + let (names, suffix) = ("FILE", "SUFFIX").unpack(operands)?; + settings.names = vec![names]; + settings.suffix = suffix; } - settings + + Ok(settings) } #[test] fn name_and_suffix() { - let settings = parse(&["basename", "foobar", "bar"]); + let settings = parse(&["basename", "foobar", "bar"]).unwrap(); assert!(!settings.zero); assert_eq!(settings.names, vec!["foobar"]); assert_eq!(settings.suffix, "bar"); @@ -55,7 +63,7 @@ fn name_and_suffix() { #[test] fn zero_name_and_suffix() { - let settings = parse(&["basename", "-z", "foobar", "bar"]); + let settings = parse(&["basename", "-z", "foobar", "bar"]).unwrap(); assert!(settings.zero); assert_eq!(settings.names, vec!["foobar"]); assert_eq!(settings.suffix, "bar"); @@ -63,7 +71,7 @@ fn zero_name_and_suffix() { #[test] fn all_and_names() { - let settings = parse(&["basename", "-a", "foobar", "bar"]); + let settings = parse(&["basename", "-a", "foobar", "bar"]).unwrap(); assert!(settings.multiple); assert!(!settings.zero); assert_eq!(settings.names, vec!["foobar", "bar"]); @@ -72,7 +80,7 @@ fn all_and_names() { #[test] fn option_like_names() { - let settings = parse(&["basename", "-a", "--", "-a", "-z", "--suffix=SUFFIX"]); + let settings = parse(&["basename", "-a", "--", "-a", "-z", "--suffix=SUFFIX"]).unwrap(); assert!(settings.multiple); assert!(!settings.zero); assert_eq!(settings.names, vec!["-a", "-z", "--suffix=SUFFIX"]); diff --git a/tests/coreutils/ls.rs b/tests/coreutils/ls.rs index 681e83c..9673926 100644 --- a/tests/coreutils/ls.rs +++ b/tests/coreutils/ls.rs @@ -38,7 +38,7 @@ impl When { Self::Always => true, Self::Never => false, // Should be atty::is(atty::Stream::Stdout), but I don't want to - // pull that depenency in just for this test. + // pull that dependency in just for this test. Self::Auto => true, } } diff --git a/tests/coreutils/mktemp.rs b/tests/coreutils/mktemp.rs index 1319709..2410f7d 100644 --- a/tests/coreutils/mktemp.rs +++ b/tests/coreutils/mktemp.rs @@ -1,6 +1,12 @@ -use std::path::{Path, PathBuf}; +use std::{ + ffi::OsString, + path::{Path, PathBuf}, +}; -use uutils_args::{Arguments, Options}; +use uutils_args::{ + positional::{Opt, Unpack}, + Arguments, Options, +}; #[derive(Clone, Arguments)] enum Arg { @@ -46,39 +52,52 @@ impl Options for Settings { } } +fn parse(args: I) -> Result<(Settings, Option), uutils_args::Error> +where + I: IntoIterator, + I::Item: Into, +{ + let (s, ops) = Settings::default().parse(args)?; + let file = Opt("FILE").unpack(ops)?; + Ok((s, file)) +} + #[test] fn suffix() { - let (s, _operands) = Settings::default() - .parse(["mktemp", "--suffix=hello"]) - .unwrap(); + let (s, _template) = parse(["mktemp", "--suffix=hello"]).unwrap(); assert_eq!(s.suffix.unwrap(), "hello"); - let (s, _operands) = Settings::default().parse(["mktemp", "--suffix="]).unwrap(); + let (s, _template) = parse(["mktemp", "--suffix="]).unwrap(); assert_eq!(s.suffix.unwrap(), ""); - let (s, _operands) = Settings::default().parse(["mktemp", "--suffix="]).unwrap(); + let (s, _template) = parse(["mktemp", "--suffix="]).unwrap(); assert_eq!(s.suffix.unwrap(), ""); - let (s, _operands) = Settings::default().parse(["mktemp"]).unwrap(); + let (s, _template) = parse(["mktemp"]).unwrap(); assert_eq!(s.suffix, None); } #[test] fn tmpdir() { - let (s, _operands) = Settings::default().parse(["mktemp", "--tmpdir"]).unwrap(); + let (s, _template) = parse(["mktemp", "--tmpdir"]).unwrap(); assert_eq!(s.tmp_dir.unwrap(), Path::new(".")); - let (s, _operands) = Settings::default().parse(["mktemp", "--tmpdir="]).unwrap(); + let (s, _template) = parse(["mktemp", "--tmpdir="]).unwrap(); assert_eq!(s.tmp_dir.unwrap(), Path::new("")); - let (s, _operands) = Settings::default().parse(["mktemp", "-p", "foo"]).unwrap(); + let (s, _template) = parse(["mktemp", "-p", "foo"]).unwrap(); assert_eq!(s.tmp_dir.unwrap(), Path::new("foo")); - let (s, _operands) = Settings::default().parse(["mktemp", "-pfoo"]).unwrap(); + let (s, _template) = parse(["mktemp", "-pfoo"]).unwrap(); assert_eq!(s.tmp_dir.unwrap(), Path::new("foo")); - let (s, _operands) = Settings::default().parse(["mktemp", "-p", ""]).unwrap(); + let (s, _template) = parse(["mktemp", "-p", ""]).unwrap(); assert_eq!(s.tmp_dir.unwrap(), Path::new("")); - assert!(Settings::default().parse(["mktemp", "-p"]).is_err()); + assert!(parse(["mktemp", "-p"]).is_err()); +} + +#[test] +fn too_many_arguments() { + assert!(parse(["mktemp", "foo", "bar"]).is_err()); }