Llewellyn
/
exa
mirror of https://github.com/Llewellynvdm/exa.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Have tests use OsStrs not OsStrings

This commit is contained in:
Benjamin Sago 2020-10-13 00:29:49 +01:00
parent ed59428cbc
commit 6f2d8cc26c
5 changed files with 38 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main.rs
View File

@ -30,7 +30,7 @@ fn main() {
logger::configure(env::var_os(vars::EXA_DEBUG));
let args: Vec<_> = env::args_os().skip(1).collect();
match Options::parse(&args, &LiveVars) {
match Options::parse(args.iter().map(|e| e.as_ref()), &LiveVars) {
OptionsResult::Ok(options, mut input_paths) => {
// List the current directory by default.

20
src/options/help.rs
View File

@ -130,32 +130,26 @@ impl fmt::Display for HelpString {
#[cfg(test)]
mod test {
use crate::options::{Options, OptionsResult};
use std::ffi::OsString;
fn os(input: &'static str) -> OsString {
let mut os = OsString::new();
os.push(input);
os
}
use std::ffi::OsStr;
#[test]
fn help() {
let args = [ os("--help") ];
let opts = Options::parse(&args, &None);
let args = vec![ OsStr::new("--help") ];
let opts = Options::parse(args, &None);
assert!(matches!(opts, OptionsResult::Help(_)));
}
#[test]
fn help_with_file() {
let args = [ os("--help"), os("me") ];
let opts = Options::parse(&args, &None);
let args = vec![ OsStr::new("--help"), OsStr::new("me") ];
let opts = Options::parse(args, &None);
assert!(matches!(opts, OptionsResult::Help(_)));
}
#[test]
fn unhelpful() {
let args = [];
let opts = Options::parse(&args, &None);
let args = vec![];
let opts = Options::parse(args, &None);
assert!(! matches!(opts, OptionsResult::Help(_))) // no help when --help isn’t passed
}
}

20
src/options/mod.rs
View File

@ -69,7 +69,7 @@
//! it’s clear what the user wants.
use std::ffi::{OsStr, OsString};
use std::ffi::OsStr;
use crate::fs::dir_action::DirAction;
use crate::fs::filter::{FileFilter, GitIgnore};
@ -120,7 +120,7 @@ impl Options {
/// for extra options.
#[allow(unused_results)]
pub fn parse<'args, I, V>(args: I, vars: &V) -> OptionsResult<'args>
where I: IntoIterator<Item = &'args OsString>,
where I: IntoIterator<Item = &'args OsStr>,
V: Vars,
{
use crate::options::parser::{Matches, Strictness};
@ -198,7 +198,7 @@ pub enum OptionsResult<'args> {
#[cfg(test)]
pub mod test {
use crate::options::parser::{Arg, MatchedFlags};
use std::ffi::OsString;
use std::ffi::OsStr;
#[derive(PartialEq, Debug)]
pub enum Strictnesses {
@ -219,27 +219,19 @@ pub mod test {
use self::Strictnesses::*;
use crate::options::parser::{Args, Strictness};
let bits = inputs.into_iter().map(|&o| os(o)).collect::<Vec<OsString>>();
let bits = inputs.into_iter().map(OsStr::new).collect::<Vec<_>>();
let mut result = Vec::new();
if strictnesses == Last || strictnesses == Both {
let results = Args(args).parse(bits.iter(), Strictness::UseLastArguments);
let results = Args(args).parse(bits.clone(), Strictness::UseLastArguments);
result.push(get(&results.unwrap().flags));
}
if strictnesses == Complain || strictnesses == Both {
let results = Args(args).parse(bits.iter(), Strictness::ComplainAboutRedundantArguments);
let results = Args(args).parse(bits, Strictness::ComplainAboutRedundantArguments);
result.push(get(&results.unwrap().flags));
}
result
}
/// Creates an `OSStr` (used in tests)
#[cfg(test)]
fn os(input: &str) -> OsString {
let mut os = OsString::new();
os.push(input);
os
}
}

56
src/options/parser.rs
View File

@ -144,7 +144,7 @@ impl Args {
/// Iterates over the given list of command-line arguments and parses
/// them into a list of matched flags and free strings.
pub fn parse<'args, I>(&self, inputs: I, strictness: Strictness) -> Result<Matches<'args>, ParseError>
where I: IntoIterator<Item = &'args OsString>
where I: IntoIterator<Item = &'args OsStr>
{
use std::os::unix::ffi::OsStrExt;
@ -507,24 +507,16 @@ fn split_on_equals(input: &OsStr) -> Option<(&OsStr, &OsStr)> {
}
/// Creates an `OSString` (used in tests)
#[cfg(test)]
fn os(input: &'static str) -> OsString {
let mut os = OsString::new();
os.push(input);
os
}
#[cfg(test)]
mod split_test {
use super::{split_on_equals, os};
use super::split_on_equals;
use std::ffi::{OsStr, OsString};
macro_rules! test_split {
($name:ident: $input:expr => None) => {
#[test]
fn $name() {
assert_eq!(split_on_equals(&os($input)),
assert_eq!(split_on_equals(&OsString::from($input)),
None);
}
};
@ -532,8 +524,8 @@ mod split_test {
($name:ident: $input:expr => $before:expr, $after:expr) => {
#[test]
fn $name() {
assert_eq!(split_on_equals(&os($input)),
Some((&*os($before), &*os($after))));
assert_eq!(split_on_equals(&OsString::from($input)),
Some((OsStr::new($before), OsStr::new($after))));
}
};
}
@ -555,29 +547,21 @@ mod split_test {
mod parse_test {
use super::*;
pub fn os(input: &'static str) -> OsString {
let mut os = OsString::new();
os.push(input);
os
}
macro_rules! test {
($name:ident: $inputs:expr => frees: $frees:expr, flags: $flags:expr) => {
#[test]
fn $name() {
// Annoyingly the input &strs need to be converted to OsStrings
let inputs: Vec<OsString> = $inputs.as_ref().into_iter().map(|&o| os(o)).collect();
let inputs: &[&'static str] = $inputs.as_ref();
let inputs = inputs.iter().map(OsStr::new);
// Same with the frees
let frees: Vec<OsString> = $frees.as_ref().into_iter().map(|&o| os(o)).collect();
let frees: Vec<&OsStr> = frees.iter().map(|os| os.as_os_str()).collect();
let frees: &[&'static str] = $frees.as_ref();
let frees = frees.iter().map(OsStr::new).collect();
let flags = <[_]>::into_vec(Box::new($flags));
let strictness = Strictness::UseLastArguments; // this isn’t even used
let got = Args(TEST_ARGS).parse(inputs.iter(), strictness);
let got = Args(TEST_ARGS).parse(inputs, strictness);
let flags = MatchedFlags { flags, strictness };
let expected = Ok(Matches { frees, flags });
@ -590,12 +574,10 @@ mod parse_test {
fn $name() {
use self::ParseError::*;
let strictness = Strictness::UseLastArguments; // this isn’t even used
let bits = $inputs.as_ref().into_iter()
.map(|&o| os(o))
.collect::<Vec<_>>();
let inputs = $inputs.iter().map(OsStr::new);
let got = Args(TEST_ARGS).parse(bits.iter(), strictness);
let strictness = Strictness::UseLastArguments; // this isn’t even used
let got = Args(TEST_ARGS).parse(inputs, strictness);
assert_eq!(got, Err($error));
}
};
@ -663,8 +645,8 @@ mod parse_test {
// Unknown args
test!(unknown_long: ["--quiet"] => error UnknownArgument { attempt: os("quiet") });
test!(unknown_long_eq: ["--quiet=shhh"] => error UnknownArgument { attempt: os("quiet") });
test!(unknown_long: ["--quiet"] => error UnknownArgument { attempt: OsString::from("quiet") });
test!(unknown_long_eq: ["--quiet=shhh"] => error UnknownArgument { attempt: OsString::from("quiet") });
test!(unknown_short: ["-q"] => error UnknownShortArgument { attempt: b'q' });
test!(unknown_short_2nd: ["-lq"] => error UnknownShortArgument { attempt: b'q' });
test!(unknown_short_eq: ["-q=shhh"] => error UnknownShortArgument { attempt: b'q' });
@ -704,7 +686,7 @@ mod matches_test {
#[test]
fn only_count() {
let everything = os("everything");
let everything = OsString::from("everything");
let flags = MatchedFlags {
flags: vec![ (Flag::Short(b'c'), Some(&*everything)) ],
@ -716,8 +698,8 @@ mod matches_test {
#[test]
fn rightmost_count() {
let everything = os("everything");
let nothing = os("nothing");
let everything = OsString::from("everything");
let nothing = OsString::from("nothing");
let flags = MatchedFlags {
flags: vec![ (Flag::Short(b'c'), Some(&*everything)),

16
src/options/version.rs
View File

@ -39,25 +39,19 @@ impl fmt::Display for VersionString {
#[cfg(test)]
mod test {
use crate::options::{Options, OptionsResult};
use std::ffi::OsString;
fn os(input: &'static str) -> OsString {
let mut os = OsString::new();
os.push(input);
os
}
use std::ffi::OsStr;
#[test]
fn version() {
let args = [ os("--version") ];
let opts = Options::parse(&args, &None);
let args = vec![ OsStr::new("--version") ];
let opts = Options::parse(args, &None);
assert!(matches!(opts, OptionsResult::Version(_)));
}
#[test]
fn version_with_file() {
let args = [ os("--version"), os("me") ];
let opts = Options::parse(&args, &None);
let args = vec![ OsStr::new("--version"), OsStr::new("me") ];
let opts = Options::parse(args, &None);
assert!(matches!(opts, OptionsResult::Version(_)));
}
}