diff --git a/src/build/arg.rs b/src/build/arg.rs
index 6f73b4c02c2e..9753bf39f30a 100644
--- a/src/build/arg.rs
+++ b/src/build/arg.rs
@@ -19,7 +19,7 @@ use yaml_rust::Yaml;
 // Internal
 use crate::build::usage_parser::UsageParser;
 use crate::build::ArgPredicate;
-use crate::util::{Id, Key};
+use crate::util::{ClapRange, Id, Key};
 use crate::PossibleValue;
 use crate::ValueHint;
 use crate::INTERNAL_ERROR_MSG;
@@ -81,8 +81,10 @@ pub struct Arg<'help> {
     pub(crate) val_names: Vec<&'help str>,
     pub(crate) num_vals: Option<usize>,
     pub(crate) max_occurs: Option<usize>,
-    pub(crate) max_vals: Option<usize>,
-    pub(crate) min_vals: Option<usize>,
+    /// Range of number of values per occurrence
+    pub(crate) num_vals_range: Option<ClapRange<usize>>,
+    /// Total number of values range
+    pub(crate) num_vals_total_range: Option<ClapRange<usize>>,
     pub(crate) validator: Option<Arc<Mutex<Validator<'help>>>>,
     pub(crate) validator_os: Option<Arc<Mutex<ValidatorOs<'help>>>>,
     pub(crate) val_delim: Option<char>,
@@ -1271,7 +1273,11 @@ impl<'help> Arg<'help> {
     #[inline]
     #[must_use]
     pub fn max_values(mut self, qty: usize) -> Self {
-        self.max_vals = Some(qty);
+        let range = self
+            .num_vals_total_range
+            .get_or_insert_with(Default::default);
+        range.end = Some(qty);
+        range.inclusive = true;
         self.takes_value(true).multiple_values(true)
     }
 
@@ -1336,7 +1342,27 @@ impl<'help> Arg<'help> {
     #[inline]
     #[must_use]
     pub fn min_values(mut self, qty: usize) -> Self {
-        self.min_vals = Some(qty);
+        self.num_vals_total_range
+            .get_or_insert_with(Default::default)
+            .start = Some(qty);
+        self.takes_value(true).multiple_values(true)
+    }
+
+    /// emm
+    pub fn takes_values<R>(mut self, range: R) -> Self
+    where
+        R: Into<ClapRange<usize>>,
+    {
+        self.num_vals_range = Some(range.into());
+        self.takes_value(true).multiple_values(true)
+    }
+
+    /// emm
+    pub fn takes_values_total<R>(mut self, range: R) -> Self
+    where
+        R: Into<ClapRange<usize>>,
+    {
+        self.num_vals_total_range = Some(range.into());
         self.takes_value(true).multiple_values(true)
     }
 
@@ -5021,6 +5047,54 @@ impl<'help> Arg<'help> {
 
 /// # Internally used only
 impl<'help> Arg<'help> {
+    pub(crate) fn has_val_num_range(&self) -> bool {
+        self.num_vals_range.is_some() || self.num_vals_total_range.is_some()
+    }
+
+    /// If has_val_num_range() == false, return false.
+    /// Or else should we accept more values.
+    pub(crate) fn need_more_vals(&self, total: usize, current: usize) -> bool {
+        if let Some(range) = &self.num_vals_total_range {
+            if !range.need_more(total) {
+                return false;
+            }
+        }
+        if let Some(range) = &self.num_vals_range {
+            if !range.need_more(current) {
+                return false;
+            }
+        }
+
+        self.has_val_num_range()
+    }
+
+    /// If has_val_num_range() == false, return false.
+    /// Or else is num_vals == 0 accepted ?
+    pub(crate) fn min_vals_zero(&self) -> bool {
+        if let Some(range) = &self.num_vals_total_range {
+            if !range.is_valid(0) {
+                return false;
+            }
+        }
+        if let Some(range) = &self.num_vals_range {
+            if !range.is_valid(0) {
+                return false;
+            }
+        }
+
+        self.has_val_num_range()
+    }
+
+    pub(crate) fn range_num_vals(&self) -> Option<usize> {
+        self.num_vals_range.as_ref().and_then(|x| x.num_vals())
+    }
+
+    pub(crate) fn range_num_vals_total(&self) -> Option<usize> {
+        self.num_vals_total_range
+            .as_ref()
+            .and_then(|x| x.num_vals())
+    }
+
     pub(crate) fn _build(&mut self) {
         if self.is_positional() {
             self.settings.set(ArgSettings::TakesValue);
@@ -5037,7 +5111,11 @@ impl<'help> Arg<'help> {
         if val_names_len > 1 {
             self.settings.set(ArgSettings::MultipleValues);
 
-            if self.num_vals.is_none() {
+            if self.num_vals.is_none()
+                && self.range_num_vals().is_none()
+                && self.range_num_vals_total().is_none()
+            {
+                // TODO(ldm0) Migrate this to `num_vals_range_total` in clap 4 since it's a breaking change.
                 self.num_vals = Some(val_names_len);
             }
         }
@@ -5147,7 +5225,7 @@ impl<'help> Display for Arg<'help> {
         }
         let mut need_closing_bracket = false;
         if !self.is_positional() && self.is_takes_value_set() {
-            let is_optional_val = self.min_vals == Some(0);
+            let is_optional_val = self.min_vals_zero();
             let sep = if self.is_require_equals_set() {
                 if is_optional_val {
                     need_closing_bracket = true;
@@ -5200,8 +5278,6 @@ impl<'help> fmt::Debug for Arg<'help> {
             .field("possible_vals", &self.possible_vals)
             .field("val_names", &self.val_names)
             .field("num_vals", &self.num_vals)
-            .field("max_vals", &self.max_vals)
-            .field("min_vals", &self.min_vals)
             .field(
                 "validator",
                 &self.validator.as_ref().map_or("None", |_| "Some(FnMut)"),
@@ -5257,9 +5333,15 @@ where
         ' '
     }
     .to_string();
+
+    let num_vals = arg
+        .num_vals
+        .or_else(|| arg.range_num_vals())
+        .or_else(|| arg.range_num_vals_total());
+
     if !arg.val_names.is_empty() {
         // If have val_name.
-        match (arg.val_names.len(), arg.num_vals) {
+        match (arg.val_names.len(), num_vals) {
             (1, Some(num_vals)) => {
                 // If single value name with multiple num_of_vals, display all
                 // the values with the single value name.
@@ -5285,7 +5367,7 @@ where
                 }
             }
         }
-    } else if let Some(num_vals) = arg.num_vals {
+    } else if let Some(num_vals) = num_vals {
         // If number_of_values is specified, display the value multiple times.
         let arg_name = format!("<{}>", arg.name);
         for n in 1..=num_vals {
diff --git a/src/build/debug_asserts.rs b/src/build/debug_asserts.rs
index 1bbf86a6130b..78ee9bc3cf0e 100644
--- a/src/build/debug_asserts.rs
+++ b/src/build/debug_asserts.rs
@@ -493,7 +493,10 @@ fn _verify_positionals(cmd: &Command) -> bool {
             .get_positionals()
             .filter(|p| {
                 p.is_multiple_occurrences_set()
-                    || (p.is_multiple_values_set() && p.num_vals.is_none())
+                    || (p.is_multiple_values_set()
+                        && p.num_vals.is_none()
+                        && p.range_num_vals().is_none()
+                        && p.range_num_vals_total().is_none())
             })
             .count();
         let ok = count <= 1
diff --git a/src/output/help.rs b/src/output/help.rs
index 9bb21cd41698..0ea93bb7c69d 100644
--- a/src/output/help.rs
+++ b/src/output/help.rs
@@ -281,7 +281,7 @@ impl<'help, 'cmd, 'writer> Help<'help, 'cmd, 'writer> {
         debug!("Help::val: arg={}", arg.name);
         let mut need_closing_bracket = false;
         if arg.is_takes_value_set() && !arg.is_positional() {
-            let is_optional_val = arg.min_vals == Some(0);
+            let is_optional_val = arg.min_vals_zero();
             let sep = if arg.is_require_equals_set() {
                 if is_optional_val {
                     need_closing_bracket = true;
diff --git a/src/parse/arg_matcher.rs b/src/parse/arg_matcher.rs
index 323fb5b9abc1..882288993331 100644
--- a/src/parse/arg_matcher.rs
+++ b/src/parse/arg_matcher.rs
@@ -186,22 +186,27 @@ impl ArgMatcher {
     pub(crate) fn needs_more_vals(&self, o: &Arg) -> bool {
         debug!("ArgMatcher::needs_more_vals: o={}", o.name);
         if let Some(ma) = self.get(&o.id) {
-            let current_num = ma.num_vals();
-            if let Some(num) = o.num_vals {
+            let num_total = ma.num_vals();
+            let num_current = ma.num_vals_last_group();
+            let needs_more_vals = if let Some(num) = o.num_vals {
                 debug!("ArgMatcher::needs_more_vals: num_vals...{}", num);
-                return if o.is_multiple_occurrences_set() {
-                    (current_num % num) != 0
+                if o.is_multiple_occurrences_set() {
+                    (num_total % num) != 0
                 } else {
-                    num != current_num
-                };
-            } else if let Some(num) = o.max_vals {
-                debug!("ArgMatcher::needs_more_vals: max_vals...{}", num);
-                return current_num < num;
-            } else if o.min_vals.is_some() {
-                debug!("ArgMatcher::needs_more_vals: min_vals...true");
-                return true;
-            }
-            return o.is_multiple_values_set();
+                    num != num_total
+                }
+            } else if o.has_val_num_range() {
+                debug!("ArgMatcher::has_val_num_range");
+                o.need_more_vals(num_total, num_current)
+            } else {
+                debug!("ArgMatcher::check is_multiple_values_set");
+                o.is_multiple_values_set()
+            };
+            debug!(
+                "ArgMatcher::needs_more_vals: {}, {}, {}",
+                needs_more_vals, num_total, num_current
+            );
+            return needs_more_vals;
         }
         true
     }
diff --git a/src/parse/matches/matched_arg.rs b/src/parse/matches/matched_arg.rs
index 55326ecd08eb..ea957096c30c 100644
--- a/src/parse/matches/matched_arg.rs
+++ b/src/parse/matches/matched_arg.rs
@@ -81,8 +81,6 @@ impl MatchedArg {
         self.vals.iter().flatten().count()
     }
 
-    // Will be used later
-    #[allow(dead_code)]
     pub(crate) fn num_vals_last_group(&self) -> usize {
         self.vals.last().map(|x| x.len()).unwrap_or(0)
     }
diff --git a/src/parse/parser.rs b/src/parse/parser.rs
index cb74532d4905..536463e40778 100644
--- a/src/parse/parser.rs
+++ b/src/parse/parser.rs
@@ -1043,7 +1043,7 @@ impl<'help, 'cmd> Parser<'help, 'cmd> {
         debug!("Parser::parse_opt; Checking for val...");
         // require_equals is set, but no '=' is provided, try throwing error.
         if opt.is_require_equals_set() && !has_eq {
-            if opt.min_vals == Some(0) {
+            if opt.min_vals_zero() {
                 debug!("Requires equals, but min_vals == 0");
                 self.inc_occurrence_of_arg(matcher, opt);
                 // We assume this case is valid: require equals, but min_vals == 0.
diff --git a/src/parse/validator.rs b/src/parse/validator.rs
index 5b801de88d32..b4feabea387c 100644
--- a/src/parse/validator.rs
+++ b/src/parse/validator.rs
@@ -4,8 +4,8 @@ use crate::error::{Error, Result as ClapResult};
 use crate::output::fmt::Stream;
 use crate::output::Usage;
 use crate::parse::{ArgMatcher, MatchedArg, ParseState};
-use crate::util::ChildGraph;
 use crate::util::Id;
+use crate::util::{ChildGraph, Ord};
 use crate::{INTERNAL_ERROR_MSG, INVALID_UTF8};
 
 pub(crate) struct Validator<'help, 'cmd> {
@@ -33,7 +33,7 @@ impl<'help, 'cmd> Validator<'help, 'cmd> {
 
             let o = &self.cmd[&a];
             let should_err = if let Some(v) = matcher.args.get(&o.id) {
-                v.all_val_groups_empty() && !(o.min_vals.is_some() && o.min_vals.unwrap() == 0)
+                v.all_val_groups_empty() && !o.min_vals_zero()
             } else {
                 true
             };
@@ -390,71 +390,116 @@ impl<'help, 'cmd> Validator<'help, 'cmd> {
 
     fn validate_arg_num_vals(&self, a: &Arg, ma: &MatchedArg) -> ClapResult<()> {
         debug!("Validator::validate_arg_num_vals");
-        if let Some(num) = a.num_vals {
-            let total_num = ma.num_vals();
-            debug!("Validator::validate_arg_num_vals: num_vals set...{}", num);
-            let should_err = if a.is_multiple_occurrences_set() {
-                total_num % num != 0
-            } else {
-                num != total_num
-            };
-            if should_err {
-                debug!("Validator::validate_arg_num_vals: Sending error WrongNumberOfValues");
-                return Err(Error::wrong_number_of_values(
-                    self.cmd,
-                    a,
-                    num,
-                    if a.is_multiple_occurrences_set() {
-                        total_num % num
-                    } else {
-                        total_num
-                    },
-                    Usage::new(self.cmd)
-                        .required(&self.required)
-                        .create_usage_with_title(&[]),
-                ));
-            }
+        let num_vals = ma.num_vals();
+        let num_current = ma.num_vals_last_group();
+
+        // Option<expected, actual>
+        let mut should_err = None;
+        if should_err.is_none() {
+            let multi_occ = a.is_multiple_occurrences_set();
+            should_err = a.num_vals.and_then(|num| {
+                if multi_occ {
+                    (num_vals % num != 0).then(|| (num, num_vals % num))
+                } else {
+                    (num != num_vals).then(|| (num, num_vals))
+                }
+            });
         }
-        if let Some(num) = a.max_vals {
-            debug!("Validator::validate_arg_num_vals: max_vals set...{}", num);
-            if ma.num_vals() > num {
-                debug!("Validator::validate_arg_num_vals: Sending error TooManyValues");
-                return Err(Error::too_many_values(
-                    self.cmd,
-                    ma.vals_flatten()
-                        .last()
-                        .expect(INTERNAL_ERROR_MSG)
-                        .to_str()
-                        .expect(INVALID_UTF8)
-                        .to_string(),
-                    a.to_string(),
-                    Usage::new(self.cmd)
-                        .required(&self.required)
-                        .create_usage_with_title(&[]),
-                ));
+        if should_err.is_none() {
+            should_err = a
+                .range_num_vals()
+                .and_then(|num| (num != num_current).then(|| (num, num_current)));
+        }
+        if should_err.is_none() {
+            should_err = a
+                .range_num_vals_total()
+                .and_then(|num| (num != num_vals).then(|| (num, num_vals)));
+        }
+        if let Some((expected, actual)) = should_err {
+            debug!("Validator::validate_arg_num_vals: Sending error WrongNumberOfValues");
+            return Err(Error::wrong_number_of_values(
+                self.cmd,
+                a,
+                expected,
+                actual,
+                Usage::new(self.cmd)
+                    .required(&self.required)
+                    .create_usage_with_title(&[]),
+            ));
+        }
+        if let Some(range) = &a.num_vals_total_range {
+            if let Err(ord) = range.pend(num_vals) {
+                match ord {
+                    Ord::Lt(num) => {
+                        debug!("Validator::validate_arg_num_vals: Sending error TooFewValues");
+                        return Err(Error::too_few_values(
+                            self.cmd,
+                            a,
+                            num,
+                            num_vals,
+                            Usage::new(self.cmd)
+                                .required(&self.required)
+                                .create_usage_with_title(&[]),
+                        ));
+                    }
+                    Ord::Gt(_num) => {
+                        debug!("Validator::validate_arg_num_vals: Sending error TooManyValues");
+                        return Err(Error::too_many_values(
+                            self.cmd,
+                            ma.vals_flatten()
+                                .last()
+                                .expect(INTERNAL_ERROR_MSG)
+                                .to_str()
+                                .expect(INVALID_UTF8)
+                                .to_string(),
+                            a.to_string(),
+                            Usage::new(self.cmd)
+                                .required(&self.required)
+                                .create_usage_with_title(&[]),
+                        ));
+                    }
+                }
             }
         }
-        let min_vals_zero = if let Some(num) = a.min_vals {
-            debug!("Validator::validate_arg_num_vals: min_vals set: {}", num);
-            if ma.num_vals() < num && num != 0 {
-                debug!("Validator::validate_arg_num_vals: Sending error TooFewValues");
-                return Err(Error::too_few_values(
-                    self.cmd,
-                    a,
-                    num,
-                    ma.num_vals(),
-                    Usage::new(self.cmd)
-                        .required(&self.required)
-                        .create_usage_with_title(&[]),
-                ));
+
+        if let Some(range) = &a.num_vals_range {
+            if let Err(ord) = range.pend(num_current) {
+                match ord {
+                    Ord::Lt(num) => {
+                        debug!("Validator::validate_arg_num_vals: Sending error TooFewValues");
+                        return Err(Error::too_few_values(
+                            self.cmd,
+                            a,
+                            num,
+                            num_current,
+                            Usage::new(self.cmd)
+                                .required(&self.required)
+                                .create_usage_with_title(&[]),
+                        ));
+                    }
+                    Ord::Gt(_num) => {
+                        debug!("Validator::validate_arg_num_vals: Sending error TooManyValues");
+                        return Err(Error::too_many_values(
+                            self.cmd,
+                            ma.vals_flatten()
+                                .last()
+                                .expect(INTERNAL_ERROR_MSG)
+                                .to_str()
+                                .expect(INVALID_UTF8)
+                                .to_string(),
+                            a.to_string(),
+                            Usage::new(self.cmd)
+                                .required(&self.required)
+                                .create_usage_with_title(&[]),
+                        ));
+                    }
+                }
             }
-            num == 0
-        } else {
-            false
-        };
+        }
+
         // Issue 665 (https://github.com/clap-rs/clap/issues/665)
         // Issue 1105 (https://github.com/clap-rs/clap/issues/1105)
-        if a.is_takes_value_set() && !min_vals_zero && ma.all_val_groups_empty() {
+        if a.is_takes_value_set() && !a.min_vals_zero() && ma.all_val_groups_empty() {
             return Err(Error::empty_value(
                 self.cmd,
                 &a.possible_vals
diff --git a/src/util/mod.rs b/src/util/mod.rs
index ed35765ff6a9..16bf1ae0bc4d 100644
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -38,3 +38,144 @@ pub(crate) fn eq_ignore_case(left: &str, right: &str) -> bool {
 
 #[cfg(feature = "unicode")]
 pub(crate) use unicase::eq as eq_ignore_case;
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug)]
+pub(crate) enum Ord {
+    Lt(usize),
+    Gt(usize),
+}
+
+#[derive(Debug, Clone)]
+pub struct ClapRange<T> {
+    pub(crate) inclusive: bool,
+    pub(crate) start: Option<T>,
+    pub(crate) end: Option<T>,
+}
+
+impl Default for ClapRange<usize> {
+    fn default() -> Self {
+        ClapRange {
+            inclusive: false,
+            start: Some(1),
+            end: None,
+        }
+    }
+}
+
+impl ClapRange<usize> {
+    pub(crate) fn is_valid(&self, num: usize) -> bool {
+        self.pend(num).is_ok()
+    }
+
+    pub(crate) fn pend(&self, num: usize) -> Result<(), Ord> {
+        if let Some(start) = self.start {
+            if num < start {
+                return Err(Ord::Lt(start));
+            }
+        }
+        if let Some(end) = self.end {
+            if self.inclusive {
+                if num > end {
+                    return Err(Ord::Gt(end));
+                }
+            } else if num >= end {
+                // Saturating would be useful only if somebody uses `..0`
+                // for the num value range.(which should be defended in arg
+                // building).
+                return Err(Ord::Gt(end.saturating_sub(1)));
+            }
+        }
+        Ok(())
+    }
+
+    /// Is more values needed to satisfy the range?
+    pub(crate) fn need_more(&self, current: usize) -> bool {
+        // Only if current + 1 is bigger than the range, we don't need more values.
+        !matches!(self.pend(current + 1), Err(Ord::Gt(_)))
+    }
+
+    pub(crate) fn num_vals(&self) -> Option<usize> {
+        if self.inclusive {
+            match (self.start, self.end) {
+                (Some(a), Some(b)) if a == b => Some(a),
+                _ => None,
+            }
+        } else {
+            match (self.start, self.end) {
+                (Some(a), Some(b)) if b - a == 1 => Some(a),
+                _ => None,
+            }
+        }
+    }
+}
+
+impl From<usize> for ClapRange<usize> {
+    fn from(num: usize) -> Self {
+        ClapRange {
+            inclusive: true,
+            start: Some(num),
+            end: Some(num),
+        }
+    }
+}
+
+impl<T> From<std::ops::Range<T>> for ClapRange<T> {
+    fn from(range: std::ops::Range<T>) -> Self {
+        ClapRange {
+            inclusive: false,
+            start: Some(range.start),
+            end: Some(range.end),
+        }
+    }
+}
+
+impl<T> From<std::ops::RangeFull> for ClapRange<T> {
+    fn from(_: std::ops::RangeFull) -> Self {
+        ClapRange {
+            inclusive: false,
+            start: None,
+            end: None,
+        }
+    }
+}
+
+impl<T> From<std::ops::RangeFrom<T>> for ClapRange<T> {
+    fn from(range: std::ops::RangeFrom<T>) -> Self {
+        ClapRange {
+            inclusive: false,
+            start: Some(range.start),
+            end: None,
+        }
+    }
+}
+
+impl<T> From<std::ops::RangeTo<T>> for ClapRange<T> {
+    fn from(range: std::ops::RangeTo<T>) -> Self {
+        ClapRange {
+            inclusive: false,
+            start: None,
+            end: Some(range.end),
+        }
+    }
+}
+
+impl<T> From<std::ops::RangeInclusive<T>> for ClapRange<T> {
+    fn from(range: std::ops::RangeInclusive<T>) -> Self {
+        let (start, end) = range.into_inner();
+        ClapRange {
+            inclusive: true,
+            start: Some(start),
+            end: Some(end),
+        }
+    }
+}
+
+impl<T> From<std::ops::RangeToInclusive<T>> for ClapRange<T> {
+    fn from(range: std::ops::RangeToInclusive<T>) -> Self {
+        ClapRange {
+            inclusive: true,
+            start: None,
+            end: Some(range.end),
+        }
+    }
+}
diff --git a/tests/builder/help.rs b/tests/builder/help.rs
index 13a7e5d56fe2..b26023eb1b8d 100644
--- a/tests/builder/help.rs
+++ b/tests/builder/help.rs
@@ -38,9 +38,11 @@ OPTIONS:
         --multvalsmo <one> <two>     Tests multiple values, and mult occs
     -o, --option <opt>...            tests options
     -O, --option3 <option3>          specific vals [possible values: fast, slow]
-        --optvaleq[=<optval>]        Tests optional value, require = sign
-        --optvalnoeq [<optval>]      Tests optional value
+        --optvaleq=<optval>          Tests optional value, require = sign
+        --optvalnoeq <optval>        Tests optional value
     -V, --version                    Print version information
+        --valeq[=<optval>...]        Tests optional value, require = sign
+        --valnoeq [<optval>...]      Tests optional value
 
 SUBCOMMANDS:
     help      Print this message or the help of the given subcommand(s)
diff --git a/tests/builder/main.rs b/tests/builder/main.rs
index 124111f10117..e1cf9340d3a9 100644
--- a/tests/builder/main.rs
+++ b/tests/builder/main.rs
@@ -45,4 +45,5 @@ mod utf16;
 mod utf8;
 mod utils;
 mod validators;
+mod value_range;
 mod version;
diff --git a/tests/builder/utils.rs b/tests/builder/utils.rs
index 4385f796cd6b..862c87df9283 100644
--- a/tests/builder/utils.rs
+++ b/tests/builder/utils.rs
@@ -83,13 +83,18 @@ pub fn complex_app() -> Command<'static> {
                 .max_values(3),
             arg!(--optvaleq <optval> "Tests optional value, require = sign")
                 .required(false)
-                .min_values(0)
                 .number_of_values(1)
                 .require_equals(true),
             arg!(--optvalnoeq <optval> "Tests optional value")
                 .required(false)
-                .min_values(0)
                 .number_of_values(1),
+            arg!(--valeq <optval> "Tests optional value, require = sign")
+                .required(false)
+                .min_values(0)
+                .require_equals(true),
+            arg!(--valnoeq <optval> "Tests optional value")
+                .required(false)
+                .min_values(0),
         ])
         .subcommand(
             Command::new("subcmd")
diff --git a/tests/builder/value_range.rs b/tests/builder/value_range.rs
new file mode 100644
index 000000000000..f1505372aef5
--- /dev/null
+++ b/tests/builder/value_range.rs
@@ -0,0 +1,938 @@
+use crate::utils;
+use clap::{arg, Arg, Command, ErrorKind};
+
+#[test]
+fn value_range_opt_missing() {
+    let r = Command::new("df")
+        .arg(
+            Arg::new("color")
+                .long("color")
+                .default_value("auto")
+                .takes_values(0..)
+                .require_equals(true)
+                .default_missing_value("always"),
+        )
+        .try_get_matches_from(vec![""]);
+    assert!(r.is_ok(), "{}", r.unwrap_err());
+    let m = r.unwrap();
+    assert!(m.is_present("color"));
+    assert_eq!(m.value_of("color").unwrap(), "auto");
+    assert_eq!(m.occurrences_of("color"), 0);
+}
+
+#[test]
+fn value_range_opt_present_with_missing_value() {
+    let r = Command::new("df")
+        .arg(
+            Arg::new("color")
+                .long("color")
+                .default_value("auto")
+                .takes_values(0..)
+                .require_equals(true)
+                .default_missing_value("always"),
+        )
+        .try_get_matches_from(vec!["", "--color"]);
+    assert!(r.is_ok(), "{}", r.unwrap_err());
+    let m = r.unwrap();
+    assert!(m.is_present("color"));
+    assert_eq!(m.value_of("color").unwrap(), "always");
+    assert_eq!(m.occurrences_of("color"), 1);
+}
+
+#[test]
+fn value_range_opt_present_with_value() {
+    let r = Command::new("df")
+        .arg(
+            Arg::new("color")
+                .long("color")
+                .default_value("auto")
+                .takes_values(0..)
+                .require_equals(true)
+                .default_missing_value("always"),
+        )
+        .try_get_matches_from(vec!["", "--color=never"]);
+    assert!(r.is_ok(), "{}", r.unwrap_err());
+    let m = r.unwrap();
+    assert!(m.is_present("color"));
+    assert_eq!(m.value_of("color").unwrap(), "never");
+    assert_eq!(m.occurrences_of("color"), 1);
+}
+
+#[test]
+fn value_range_issue_1374() {
+    let cmd = Command::new("MyApp").arg(
+        Arg::new("input")
+            .takes_value(true)
+            .long("input")
+            .overrides_with("input")
+            .takes_values_total(0..)
+            .multiple_occurrences(true),
+    );
+    let matches = cmd
+        .clone()
+        .try_get_matches_from(&["MyApp", "--input", "a", "b", "c", "--input", "d"])
+        .unwrap();
+    let vs = matches.values_of("input").unwrap();
+    assert_eq!(vs.collect::<Vec<_>>(), vec!["a", "b", "c", "d"]);
+    let matches = cmd
+        .clone()
+        .try_get_matches_from(&["MyApp", "--input", "a", "b", "--input", "c", "d"])
+        .unwrap();
+    let vs = matches.values_of("input").unwrap();
+    assert_eq!(vs.collect::<Vec<_>>(), vec!["a", "b", "c", "d"]);
+}
+
+#[test]
+fn value_range_option_min_exact() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values_total(3..)
+                .multiple_occurrences(true),
+        )
+        .try_get_matches_from(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("option"));
+    assert_eq!(m.occurrences_of("option"), 3);
+    assert_eq!(
+        m.values_of("option").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3"]
+    );
+}
+
+#[test]
+fn value_range_opt_min_less_multi_occ() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values_total(3..)
+                .multiple_occurrences(true),
+        )
+        .try_get_matches_from(vec!["", "-o", "val1", "-o", "val2"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::TooFewValues);
+}
+
+#[test]
+fn value_range_less() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values(3..),
+        )
+        .try_get_matches_from(vec!["", "-o", "val1", "val2"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::TooFewValues);
+}
+
+#[test]
+fn value_range_option_short_min_more_mult_occurs() {
+    let res = Command::new("multiple_values")
+        .arg(Arg::new("arg").required(true))
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values_total(3..)
+                .multiple_occurrences(true),
+        )
+        .try_get_matches_from(vec![
+            "", "pos", "-o", "val1", "-o", "val2", "-o", "val3", "-o", "val4",
+        ]);
+
+    assert!(res.is_ok(), "{:?}", res.unwrap_err().kind());
+    let m = res.unwrap();
+
+    assert!(m.is_present("option"));
+    assert!(m.is_present("arg"));
+    assert_eq!(m.occurrences_of("option"), 4);
+    assert_eq!(
+        m.values_of("option").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3", "val4"]
+    );
+    assert_eq!(m.value_of("arg"), Some("pos"));
+}
+
+#[test]
+fn option_short_min_more_single_occur() {
+    let res = Command::new("multiple_values")
+        .arg(Arg::new("arg").required(true))
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values(3..),
+        )
+        .try_get_matches_from(vec!["", "pos", "-o", "val1", "val2", "val3", "val4"]);
+
+    assert!(res.is_ok(), "{:?}", res.unwrap_err().kind());
+    let m = res.unwrap();
+
+    assert!(m.is_present("option"));
+    assert!(m.is_present("arg"));
+    assert_eq!(m.occurrences_of("option"), 1);
+    assert_eq!(
+        m.values_of("option").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3", "val4"]
+    );
+    assert_eq!(m.value_of("arg"), Some("pos"));
+}
+
+#[test]
+fn positional_min_exact() {
+    let m = Command::new("multiple_values")
+        .arg(Arg::new("pos").help("multiple positionals").min_values(3))
+        .try_get_matches_from(vec!["myprog", "val1", "val2", "val3"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("pos"));
+    assert_eq!(m.occurrences_of("pos"), 3);
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3"]
+    );
+}
+
+#[test]
+fn value_range_positional_min_less() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("pos")
+                .help("multiple positionals")
+                .takes_values(3..),
+        )
+        .try_get_matches_from(vec!["myprog", "val1", "val2"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::TooFewValues);
+}
+
+#[test]
+fn value_range_positional_min_more() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("pos")
+                .help("multiple positionals")
+                .takes_values(3..),
+        )
+        .try_get_matches_from(vec!["myprog", "val1", "val2", "val3", "val4"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("pos"));
+    assert_eq!(m.occurrences_of("pos"), 4);
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3", "val4"]
+    );
+}
+
+#[test]
+fn value_range_positional_min_less_total() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("pos")
+                .help("multiple positionals")
+                .takes_values_total(3..),
+        )
+        .try_get_matches_from(vec!["myprog", "val1", "val2"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::TooFewValues);
+}
+
+#[test]
+fn value_range_positional_min_more_total() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("pos")
+                .help("multiple positionals")
+                .takes_values_total(3..),
+        )
+        .try_get_matches_from(vec!["myprog", "val1", "val2", "val3", "val4"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("pos"));
+    assert_eq!(m.occurrences_of("pos"), 4);
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3", "val4"]
+    );
+}
+
+#[test]
+fn value_range_require_equals_min_values_zero() {
+    let res = Command::new("prog")
+        .arg(
+            Arg::new("cfg")
+                .takes_values(0..)
+                .require_equals(true)
+                .long("config"),
+        )
+        .arg(Arg::new("cmd"))
+        .try_get_matches_from(vec!["prog", "--config", "cmd"]);
+    assert!(res.is_ok(), "{}", res.unwrap_err());
+    let m = res.unwrap();
+    assert!(m.is_present("cfg"));
+    assert_eq!(m.value_of("cmd"), Some("cmd"));
+}
+
+#[test]
+fn value_range_issue_1047_min_zero_vals_default_val() {
+    let m = Command::new("foo")
+        .arg(
+            Arg::new("del")
+                .short('d')
+                .long("del")
+                .takes_values(0..)
+                .require_equals(true)
+                .default_missing_value("default"),
+        )
+        .try_get_matches_from(vec!["foo", "-d"])
+        .unwrap();
+    assert_eq!(m.occurrences_of("del"), 1);
+    assert_eq!(m.value_of("del"), Some("default"));
+}
+
+#[test]
+fn issue_1374_overrides_self_with_multiple_values() {
+    let cmd = Command::new("test").arg(
+        Arg::new("input")
+            .long("input")
+            .takes_values(0..)
+            .overrides_with("input"),
+    );
+    let m = cmd
+        .clone()
+        .try_get_matches_from(&["test", "--input", "a", "b", "c", "--input", "d"])
+        .unwrap();
+    assert_eq!(m.values_of("input").unwrap().collect::<Vec<_>>(), &["d"]);
+    let m = cmd
+        .clone()
+        .try_get_matches_from(&["test", "--input", "a", "b", "--input", "c", "d"])
+        .unwrap();
+    assert_eq!(
+        m.values_of("input").unwrap().collect::<Vec<_>>(),
+        &["c", "d"]
+    );
+}
+
+#[test]
+fn value_range_required_unless_present_with_optional_value() {
+    let res = Command::new("unlesstest")
+        .arg(Arg::new("opt").long("opt").takes_values(0..=1))
+        .arg(
+            Arg::new("cfg")
+                .required_unless_present("dbg")
+                .takes_value(true)
+                .long("config"),
+        )
+        .arg(Arg::new("dbg").long("debug"))
+        .try_get_matches_from(vec!["unlesstest", "--opt"]);
+
+    assert!(res.is_err());
+    assert_eq!(res.unwrap_err().kind(), ErrorKind::MissingRequiredArgument);
+}
+
+#[test]
+fn value_range_short_flag_require_equals_with_minvals_zero() {
+    let m = Command::new("foo")
+        .arg(
+            Arg::new("check")
+                .short('c')
+                .takes_values(0..)
+                .require_equals(true),
+        )
+        .arg(Arg::new("unique").short('u'))
+        .try_get_matches_from(&["foo", "-cu"])
+        .unwrap();
+    assert!(m.is_present("check"));
+    assert!(m.is_present("unique"));
+}
+
+#[test]
+fn value_range_issue_2624() {
+    let matches = Command::new("foo")
+        .arg(
+            Arg::new("check")
+                .short('c')
+                .long("check")
+                .require_equals(true)
+                .takes_values(0..)
+                .possible_values(["silent", "quiet", "diagnose-first"]),
+        )
+        .arg(Arg::new("unique").short('u').long("unique"))
+        .try_get_matches_from(&["foo", "-cu"])
+        .unwrap();
+    assert!(matches.is_present("check"));
+    assert!(matches.is_present("unique"));
+}
+
+#[test]
+fn value_range_option_max_exact() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values_total(..=3)
+                .multiple_occurrences(true),
+        )
+        .try_get_matches_from(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("option"));
+    assert_eq!(m.occurrences_of("option"), 3);
+    assert_eq!(
+        m.values_of("option").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3"]
+    );
+}
+
+#[test]
+fn value_range_option_max_less() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values_total(..=3)
+                .multiple_occurrences(true),
+        )
+        .try_get_matches_from(vec!["", "-o", "val1", "-o", "val2"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("option"));
+    assert_eq!(m.occurrences_of("option"), 2);
+    assert_eq!(
+        m.values_of("option").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2"]
+    );
+}
+
+#[test]
+fn value_range_option_max_more() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values_total(..=3)
+                .multiple_occurrences(true),
+        )
+        .try_get_matches_from(vec![
+            "", "-o", "val1", "-o", "val2", "-o", "val3", "-o", "val4",
+        ]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::TooManyValues);
+}
+
+#[test]
+fn value_range_positional_max_exact() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("pos")
+                .help("multiple positionals")
+                .takes_values(..=3),
+        )
+        .try_get_matches_from(vec!["myprog", "val1", "val2", "val3"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("pos"));
+    assert_eq!(m.occurrences_of("pos"), 3);
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3"]
+    );
+}
+
+#[test]
+fn value_range_positional_max_less() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("pos")
+                .help("multiple positionals")
+                .takes_values(..=3),
+        )
+        .try_get_matches_from(vec!["myprog", "val1", "val2"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("pos"));
+    assert_eq!(m.occurrences_of("pos"), 2);
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2"]
+    );
+}
+
+#[test]
+fn value_range_positional_max_more() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("pos")
+                .help("multiple positionals")
+                .takes_values(..=3),
+        )
+        .try_get_matches_from(vec!["myprog", "val1", "val2", "val3", "val4"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::TooManyValues);
+}
+
+#[test]
+fn value_range_issue_1480_max_values_consumes_extra_arg_1() {
+    let res = Command::new("prog")
+        .arg(Arg::new("field").takes_values(..=1).long("field"))
+        .arg(Arg::new("positional").required(true).index(1))
+        .try_get_matches_from(vec!["prog", "--field", "1", "file"]);
+
+    assert!(res.is_ok(), "{}", res.unwrap_err());
+}
+
+#[test]
+fn value_range_issue_1480_max_values_consumes_extra_arg_2() {
+    let res = Command::new("prog")
+        .arg(Arg::new("field").takes_values(..=1).long("field"))
+        .try_get_matches_from(vec!["prog", "--field", "1", "2"]);
+
+    assert!(res.is_err());
+    assert_eq!(res.unwrap_err().kind(), ErrorKind::UnknownArgument);
+}
+
+#[test]
+fn value_range_issue_1480_max_values_consumes_extra_arg_3() {
+    let res = Command::new("prog")
+        .arg(Arg::new("field").takes_values(..=1).long("field"))
+        .try_get_matches_from(vec!["prog", "--field", "1", "2", "3"]);
+
+    assert!(res.is_err());
+    assert_eq!(res.unwrap_err().kind(), ErrorKind::UnknownArgument);
+}
+
+#[test]
+fn value_range_aaos_opts_mult() {
+    // opts with multiple
+    let res = Command::new("posix")
+        .args_override_self(true)
+        .arg(
+            arg!(--opt <val> ... "some option")
+                .takes_values_total(4)
+                .use_value_delimiter(true)
+                .require_value_delimiter(true),
+        )
+        .try_get_matches_from(vec!["", "--opt=some", "--opt=other", "--opt=one,two"]);
+    assert!(res.is_ok(), "{}", res.unwrap_err());
+    let m = res.unwrap();
+    assert!(m.is_present("opt"));
+    assert_eq!(m.occurrences_of("opt"), 3);
+    assert_eq!(
+        m.values_of("opt").unwrap().collect::<Vec<_>>(),
+        &["some", "other", "one", "two"]
+    );
+}
+
+#[test]
+fn value_range_multiple_defaults() {
+    let r = Command::new("diff")
+        .arg(
+            Arg::new("files")
+                .long("files")
+                .takes_values(2)
+                .allow_invalid_utf8(true)
+                .default_values(&["old", "new"]),
+        )
+        .try_get_matches_from(vec![""]);
+    assert!(r.is_ok(), "{}", r.unwrap_err());
+    let m = r.unwrap();
+    assert!(m.is_present("files"));
+    assert_eq!(m.values_of_lossy("files").unwrap(), vec!["old", "new"]);
+}
+
+#[test]
+fn multiple_defaults_override() {
+    let r = Command::new("diff")
+        .arg(
+            Arg::new("files")
+                .long("files")
+                .takes_values(2)
+                .allow_invalid_utf8(true)
+                .default_values(&["old", "new"]),
+        )
+        .try_get_matches_from(vec!["", "--files", "other", "mine"]);
+    assert!(r.is_ok(), "{}", r.unwrap_err());
+    let m = r.unwrap();
+    assert!(m.is_present("files"));
+    assert_eq!(m.values_of_lossy("files").unwrap(), vec!["other", "mine"]);
+}
+
+#[test]
+fn value_range_issue_1050_num_vals_and_defaults() {
+    let res = Command::new("hello")
+        .arg(
+            Arg::new("exit-code")
+                .long("exit-code")
+                .takes_value(true)
+                .takes_values(1)
+                .default_value("0"),
+        )
+        .try_get_matches_from(vec!["hello", "--exit-code=1"]);
+    assert!(res.is_ok(), "{}", res.unwrap_err());
+    let m = res.unwrap();
+    assert_eq!(m.value_of("exit-code"), Some("1"));
+}
+
+#[test]
+fn value_range_issue_760() {
+    // Using takes_values(1) with multiple_values(true) misaligns help message
+    static ISSUE_760: &str = "ctest 0.1
+
+USAGE:
+    ctest [OPTIONS]
+
+OPTIONS:
+    -h, --help               Print help information
+    -o, --option <option>    tests options
+    -O, --opt <opt>          tests options
+    -V, --version            Print version information
+";
+
+    let cmd = Command::new("ctest")
+        .version("0.1")
+        .arg(
+            Arg::new("option")
+                .help("tests options")
+                .short('o')
+                .long("option")
+                .takes_values(1)
+                .multiple_values(true),
+        )
+        .arg(
+            Arg::new("opt")
+                .help("tests options")
+                .short('O')
+                .long("opt")
+                .takes_value(true),
+        );
+    utils::assert_output(cmd, "ctest --help", ISSUE_760, false);
+}
+
+#[test]
+fn value_range_issue_1571() {
+    let cmd = Command::new("hello").arg(
+        Arg::new("name")
+            .long("package")
+            .short('p')
+            .takes_values(1)
+            .multiple_values(true),
+    );
+    utils::assert_output(
+        cmd,
+        "hello --help",
+        "hello 
+
+USAGE:
+    hello [OPTIONS]
+
+OPTIONS:
+    -h, --help              Print help information
+    -p, --package <name>    
+",
+        false,
+    );
+}
+
+#[test]
+fn value_range_issue_2508_number_of_values_with_single_value_name() {
+    let cmd = Command::new("my_app")
+        .arg(Arg::new("some_arg").long("some_arg").takes_values(2))
+        .arg(
+            Arg::new("some_arg_issue")
+                .long("some_arg_issue")
+                .takes_values(2)
+                .value_name("ARG"),
+        );
+    utils::assert_output(
+        cmd,
+        "my_app --help",
+        "my_app 
+
+USAGE:
+    my_app [OPTIONS]
+
+OPTIONS:
+    -h, --help                              Print help information
+        --some_arg <some_arg> <some_arg>    
+        --some_arg_issue <ARG> <ARG>        
+",
+        false,
+    );
+}
+
+#[test]
+fn value_range_option_exact_exact() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values_total(3)
+                .multiple_occurrences(true),
+        )
+        .try_get_matches_from(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("option"));
+    assert_eq!(m.occurrences_of("option"), 3);
+    assert_eq!(
+        m.values_of("option").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3"]
+    );
+}
+
+#[test]
+fn value_range_option_exact_exact_not_mult() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values(3),
+        )
+        .try_get_matches_from(vec!["", "-o", "val1", "val2", "val3"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("option"));
+    assert_eq!(m.occurrences_of("option"), 1);
+    assert_eq!(
+        m.values_of("option").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3"]
+    );
+}
+
+#[test]
+fn value_range_option_exact_exact_mult() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values(3)
+                .multiple_occurrences(true),
+        )
+        .try_get_matches_from(vec![
+            "", "-o", "val1", "val2", "val3", "-o", "val4", "val5", "val6",
+        ]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("option"));
+    assert_eq!(m.occurrences_of("option"), 2);
+    assert_eq!(
+        m.values_of("option").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3", "val4", "val5", "val6"]
+    );
+}
+
+#[test]
+fn value_range_option_exact_less() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values_total(3)
+                .multiple_occurrences(true),
+        )
+        .try_get_matches_from(vec!["", "-o", "val1", "-o", "val2"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::WrongNumberOfValues);
+}
+
+#[test]
+fn value_range_option_exact_more() {
+    let m = Command::new("multiple_values")
+        .arg(
+            Arg::new("option")
+                .short('o')
+                .help("multiple options")
+                .takes_values_total(3)
+                .multiple_occurrences(true),
+        )
+        .try_get_matches_from(vec![
+            "", "-o", "val1", "-o", "val2", "-o", "val3", "-o", "val4",
+        ]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::WrongNumberOfValues);
+}
+
+#[test]
+fn value_range_positional_exact_exact() {
+    let m = Command::new("multiple_values")
+        .arg(Arg::new("pos").help("multiple positionals").takes_values(3))
+        .try_get_matches_from(vec!["myprog", "val1", "val2", "val3"]);
+
+    assert!(m.is_ok(), "{}", m.unwrap_err());
+    let m = m.unwrap();
+
+    assert!(m.is_present("pos"));
+    assert_eq!(m.occurrences_of("pos"), 3);
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3"]
+    );
+}
+
+#[test]
+fn value_range_positional_exact_less() {
+    let m = Command::new("multiple_values")
+        .arg(Arg::new("pos").help("multiple positionals").takes_values(3))
+        .try_get_matches_from(vec!["myprog", "val1", "val2"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::WrongNumberOfValues);
+}
+
+#[test]
+fn value_range_positional_exact_more() {
+    let m = Command::new("multiple_values")
+        .arg(Arg::new("pos").help("multiple positionals").takes_values(3))
+        .try_get_matches_from(vec!["myprog", "val1", "val2", "val3", "val4"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::WrongNumberOfValues);
+}
+
+#[test]
+fn value_range_issue_2229() {
+    let m = Command::new("multiple_values")
+        .arg(Arg::new("pos").help("multiple positionals").takes_values(3))
+        .try_get_matches_from(vec![
+            "myprog", "val1", "val2", "val3", "val4", "val5", "val6",
+        ]);
+
+    assert!(m.is_err()); // This panics, because `m.is_err() == false`.
+    assert_eq!(m.unwrap_err().kind(), ErrorKind::WrongNumberOfValues);
+}
+
+#[test]
+fn value_range_number_of_values_preferred_over_value_names() {
+    let m = Command::new("test")
+        .arg(
+            Arg::new("pos")
+                .long("pos")
+                .takes_values(4)
+                .value_names(&["who", "what", "why"]),
+        )
+        .try_get_matches_from(vec!["myprog", "--pos", "val1", "val2", "val3", "val4"]);
+
+    assert!(m.is_ok(), "{:?}", m.unwrap_err().kind());
+    let m = m.unwrap();
+
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3", "val4"]
+    );
+}
+
+#[test]
+fn value_range_values_per_occurrence_named() {
+    let mut a = Command::new("test").arg(
+        Arg::new("pos")
+            .long("pos")
+            .takes_values(2)
+            .multiple_occurrences(true),
+    );
+
+    let m = a.try_get_matches_from_mut(vec!["myprog", "--pos", "val1", "val2"]);
+    let m = match m {
+        Ok(m) => m,
+        Err(err) => panic!("{}", err),
+    };
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2"]
+    );
+
+    let m = a.try_get_matches_from_mut(vec![
+        "myprog", "--pos", "val1", "val2", "--pos", "val3", "val4",
+    ]);
+    let m = match m {
+        Ok(m) => m,
+        Err(err) => panic!("{}", err),
+    };
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3", "val4"]
+    );
+}
+
+#[test]
+fn value_range_leading_hyphen_with_only_pos_follows() {
+    let r = Command::new("mvae")
+        .arg(
+            arg!(o: -o [opt] ... "some opt")
+                .takes_values(1)
+                .allow_hyphen_values(true),
+        )
+        .arg(arg!([arg] "some arg"))
+        .try_get_matches_from(vec!["", "-o", "-2", "--", "val"]);
+    assert!(r.is_ok(), "{:?}", r);
+    let m = r.unwrap();
+    assert!(m.is_present("o"));
+    assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["-2"]);
+    assert_eq!(m.value_of("arg"), Some("val"));
+}
+
+#[test]
+fn value_range_mult_option_require_delim_overrides_itself() {
+    let res = Command::new("posix")
+        .arg(
+            arg!(--opt <val> ... "some option")
+                .required(false)
+                .overrides_with("opt")
+                .takes_values_total(4)
+                .use_value_delimiter(true)
+                .require_value_delimiter(true),
+        )
+        .try_get_matches_from(vec!["", "--opt=some", "--opt=other", "--opt=one,two"]);
+    assert!(res.is_ok(), "{}", res.unwrap_err());
+    let m = res.unwrap();
+    assert!(m.is_present("opt"));
+    assert_eq!(m.occurrences_of("opt"), 3);
+    assert_eq!(
+        m.values_of("opt").unwrap().collect::<Vec<_>>(),
+        &["some", "other", "one", "two"]
+    );
+}
diff --git a/tests/derive/options.rs b/tests/derive/options.rs
index 88507eb113c1..939fcabb1306 100644
--- a/tests/derive/options.rs
+++ b/tests/derive/options.rs
@@ -380,6 +380,33 @@ fn option_vec_type_structopt_behavior() {
     assert_eq!(Opt { arg: None }, Opt::try_parse_from(&["test"]).unwrap());
 }
 
+#[test]
+fn value_range_option_vec_type_structopt_behavior() {
+    #[derive(Parser, PartialEq, Debug)]
+    struct Opt {
+        #[clap(short, long, multiple_values(true), takes_values(0..))]
+        arg: Option<Vec<i32>>,
+    }
+    assert_eq!(
+        Opt { arg: Some(vec![1]) },
+        Opt::try_parse_from(&["test", "-a", "1"]).unwrap()
+    );
+
+    assert_eq!(
+        Opt {
+            arg: Some(vec![1, 2])
+        },
+        Opt::try_parse_from(&["test", "-a", "1", "2"]).unwrap()
+    );
+
+    assert_eq!(
+        Opt { arg: Some(vec![]) },
+        Opt::try_parse_from(&["test", "-a"]).unwrap()
+    );
+
+    assert_eq!(Opt { arg: None }, Opt::try_parse_from(&["test"]).unwrap());
+}
+
 #[test]
 fn two_option_vec_types() {
     #[derive(Parser, PartialEq, Debug)]