From 84e20151d99871b5a54c9bafaf99a1903dea8cbb Mon Sep 17 00:00:00 2001 From: Sean Allred Date: Thu, 28 Dec 2023 10:05:07 -0600 Subject: [PATCH] WIP -- move new tests into possible_values.rs Keeps all the possible_values tests in one file but allows the entire set of tests to be controlled by the 'strings' feature (which is required to be able to use String rather than str for each possible value). --- tests/builder/main.rs | 1 - tests/builder/possible_values.rs | 142 +++++++++++++++++++++ tests/builder/possible_values_expensive.rs | 140 -------------------- 3 files changed, 142 insertions(+), 141 deletions(-) delete mode 100644 tests/builder/possible_values_expensive.rs diff --git a/tests/builder/main.rs b/tests/builder/main.rs index 5bd872183783..22fdd5f0461c 100644 --- a/tests/builder/main.rs +++ b/tests/builder/main.rs @@ -37,7 +37,6 @@ mod opts; mod positionals; mod posix_compatible; mod possible_values; -mod possible_values_expensive; mod propagate_globals; mod require; mod subcommands; diff --git a/tests/builder/possible_values.rs b/tests/builder/possible_values.rs index b39517279bef..de66cf8650f2 100644 --- a/tests/builder/possible_values.rs +++ b/tests/builder/possible_values.rs @@ -472,3 +472,145 @@ fn ignore_case_multiple_fail() { assert!(m.is_err()); assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidValue); } + +#[cfg(feature = "string")] +mod expensive { + use std::sync::{Arc, Mutex}; + + use clap::{Arg, Command}; + use clap_builder::builder::{PossibleValue, PossibleValuesParser, TypedValueParser}; + + #[cfg(feature = "error-context")] + use super::utils; + + #[derive(Clone)] + struct ExpensiveValues { + iterated: Arc>, + } + + impl ExpensiveValues { + pub fn new() -> Self { + ExpensiveValues { + iterated: Arc::new(Mutex::new(false)), + } + } + } + + impl IntoIterator for ExpensiveValues { + type Item = String; + + type IntoIter = ExpensiveValuesIntoIterator; + + fn into_iter(self) -> Self::IntoIter { + ExpensiveValuesIntoIterator { me: self, index: 0 } + } + } + + struct ExpensiveValuesIntoIterator { + me: ExpensiveValues, + index: usize, + } + + impl Iterator for ExpensiveValuesIntoIterator { + type Item = String; + fn next(&mut self) -> Option { + let mut guard = self + .me + .iterated + .lock() + .expect("not working across multiple threads"); + + *guard = true; + self.index += 1; + + if self.index < 3 { + Some(format!("expensive-value-{}", self.index)) + } else { + None + } + } + } + + impl TypedValueParser for ExpensiveValues { + type Value = String; + + fn parse_ref( + &self, + _cmd: &clap_builder::Command, + _arg: Option<&clap_builder::Arg>, + _value: &std::ffi::OsStr, + ) -> Result { + todo!() + } + + fn possible_values(&self) -> Option + '_>> { + Some(Box::new(self.clone().into_iter().map(PossibleValue::from))) + } + } + + #[test] + fn no_iterate_when_hidden() { + static PV_EXPECTED: &str = "\ +Usage: clap-test [some-cheap-option] [some-expensive-option] + +Arguments: + [some-cheap-option] cheap [possible values: some, cheap, values] + [some-expensive-option] expensive + +Options: + -h, --help Print help +"; + let expensive = ExpensiveValues::new(); + utils::assert_output( + Command::new("test") + .arg( + Arg::new("some-cheap-option") + .help("cheap") + .value_parser(PossibleValuesParser::new(["some", "cheap", "values"])), + ) + .arg( + Arg::new("some-expensive-option") + .help("expensive") + .hide_possible_values(true) + .value_parser(expensive.clone()), + ), + "clap-test -h", + PV_EXPECTED, + false, + ); + assert_eq!(*expensive.iterated.lock().unwrap(), false); + } + + #[test] + fn iterate_when_displayed() { + static PV_EXPECTED: &str = "\ +Usage: clap-test [some-cheap-option] [some-expensive-option] + +Arguments: + [some-cheap-option] cheap [possible values: some, cheap, values] + [some-expensive-option] expensive [possible values: expensive-value-1, expensive-value-2] + +Options: + -h, --help Print help +"; + let expensive = ExpensiveValues::new(); + utils::assert_output( + Command::new("test") + .arg( + Arg::new("some-cheap-option") + .help("cheap") + .value_parser(PossibleValuesParser::new(["some", "cheap", "values"])), + ) + .arg( + Arg::new("some-expensive-option") + .help("expensive") + .hide_possible_values(false) + .value_parser(expensive.clone()), + ), + "clap-test -h", + PV_EXPECTED, + false, + ); + assert_eq!(*expensive.iterated.lock().unwrap(), true); + } +} diff --git a/tests/builder/possible_values_expensive.rs b/tests/builder/possible_values_expensive.rs deleted file mode 100644 index 5cefae3ecc45..000000000000 --- a/tests/builder/possible_values_expensive.rs +++ /dev/null @@ -1,140 +0,0 @@ -#![cfg(feature = "string")] - -use std::sync::{Arc, Mutex}; - -use clap::{Arg, Command}; -use clap_builder::builder::{PossibleValue, PossibleValuesParser, TypedValueParser}; - -#[cfg(feature = "error-context")] -use super::utils; - -#[derive(Clone)] -struct ExpensiveValues { - iterated: Arc>, -} - -impl ExpensiveValues { - pub fn new() -> Self { - ExpensiveValues { - iterated: Arc::new(Mutex::new(false)), - } - } -} - -impl IntoIterator for ExpensiveValues { - type Item = String; - - type IntoIter = ExpensiveValuesIntoIterator; - - fn into_iter(self) -> Self::IntoIter { - ExpensiveValuesIntoIterator { me: self, index: 0 } - } -} - -struct ExpensiveValuesIntoIterator { - me: ExpensiveValues, - index: usize, -} - -impl Iterator for ExpensiveValuesIntoIterator { - type Item = String; - fn next(&mut self) -> Option { - let mut guard = self - .me - .iterated - .lock() - .expect("not working across multiple threads"); - - *guard = true; - self.index += 1; - - if self.index < 3 { - Some(format!("expensive-value-{}", self.index)) - } else { - None - } - } -} - -impl TypedValueParser for ExpensiveValues { - type Value = String; - - fn parse_ref( - &self, - _cmd: &clap_builder::Command, - _arg: Option<&clap_builder::Arg>, - _value: &std::ffi::OsStr, - ) -> Result { - todo!() - } - - fn possible_values(&self) -> Option + '_>> { - Some(Box::new(self.clone().into_iter().map(PossibleValue::from))) - } -} - -#[test] -fn no_iterate_when_hidden() { - static PV_EXPECTED: &str = "\ -Usage: clap-test [some-cheap-option] [some-expensive-option] - -Arguments: - [some-cheap-option] cheap [possible values: some, cheap, values] - [some-expensive-option] expensive - -Options: - -h, --help Print help -"; - let expensive = ExpensiveValues::new(); - utils::assert_output( - Command::new("test") - .arg( - Arg::new("some-cheap-option") - .help("cheap") - .value_parser(PossibleValuesParser::new(["some", "cheap", "values"])), - ) - .arg( - Arg::new("some-expensive-option") - .help("expensive") - .hide_possible_values(true) - .value_parser(expensive.clone()), - ), - "clap-test -h", - PV_EXPECTED, - false, - ); - assert_eq!(*expensive.iterated.lock().unwrap(), false); -} - -#[test] -fn iterate_when_displayed() { - static PV_EXPECTED: &str = "\ -Usage: clap-test [some-cheap-option] [some-expensive-option] - -Arguments: - [some-cheap-option] cheap [possible values: some, cheap, values] - [some-expensive-option] expensive [possible values: expensive-value-1, expensive-value-2] - -Options: - -h, --help Print help -"; - let expensive = ExpensiveValues::new(); - utils::assert_output( - Command::new("test") - .arg( - Arg::new("some-cheap-option") - .help("cheap") - .value_parser(PossibleValuesParser::new(["some", "cheap", "values"])), - ) - .arg( - Arg::new("some-expensive-option") - .help("expensive") - .hide_possible_values(false) - .value_parser(expensive.clone()), - ), - "clap-test -h", - PV_EXPECTED, - false, - ); - assert_eq!(*expensive.iterated.lock().unwrap(), true); -}