Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 1583 insertions, 0 deletions

diff --git a/third_party/rust/nom/src/multi/mod.rs b/third_party/rust/nom/src/multi/mod.rs
new file mode 100644
index 0000000000..73129084e2
--- /dev/null
+++ b/third_party/rust/nom/src/multi/mod.rs
@@ -0,0 +1,1049 @@
+//! Combinators applying their child parser multiple times
+
+#[cfg(test)]
+mod tests;
+
+use crate::error::ErrorKind;
+use crate::error::ParseError;
+use crate::internal::{Err, IResult, Needed, Parser};
+#[cfg(feature = "alloc")]
+use crate::lib::std::vec::Vec;
+use crate::traits::{InputLength, InputTake, ToUsize};
+use core::num::NonZeroUsize;
+
+/// Don't pre-allocate more than 64KiB when calling `Vec::with_capacity`.
+///
+/// Pre-allocating memory is a nice optimization but count fields can't
+/// always be trusted. We should clamp initial capacities to some reasonable
+/// amount. This reduces the risk of a bogus count value triggering a panic
+/// due to an OOM error.
+///
+/// This does not affect correctness. Nom will always read the full number
+/// of elements regardless of the capacity cap.
+#[cfg(feature = "alloc")]
+const MAX_INITIAL_CAPACITY_BYTES: usize = 65536;
+
+/// Repeats the embedded parser, gathering the results in a `Vec`.
+///
+/// This stops on [`Err::Error`] and returns the results that were accumulated. To instead chain an error up, see
+/// [`cut`][crate::combinator::cut].
+///
+/// # Arguments
+/// * `f` The parser to apply.
+///
+/// *Note*: if the parser passed in accepts empty inputs (like `alpha0` or `digit0`), `many0` will
+/// return an error, to prevent going into an infinite loop
+///
+/// ```rust
+/// # use nom::{Err, error::ErrorKind, Needed, IResult};
+/// use nom::multi::many0;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   many0(tag("abc"))(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Ok(("123123", vec![])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// ```
+#[cfg(feature = "alloc")]
+#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+pub fn many0<I, O, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  E: ParseError<I>,
+{
+  move |mut i: I| {
+    let mut acc = crate::lib::std::vec::Vec::with_capacity(4);
+    loop {
+      let len = i.input_len();
+      match f.parse(i.clone()) {
+        Err(Err::Error(_)) => return Ok((i, acc)),
+        Err(e) => return Err(e),
+        Ok((i1, o)) => {
+          // infinite loop check: the parser must always consume
+          if i1.input_len() == len {
+            return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many0)));
+          }
+
+          i = i1;
+          acc.push(o);
+        }
+      }
+    }
+  }
+}
+
+/// Runs the embedded parser, gathering the results in a `Vec`.
+///
+/// This stops on [`Err::Error`] if there is at least one result,  and returns the results that were accumulated. To instead chain an error up,
+/// see [`cut`][crate::combinator::cut].
+///
+/// # Arguments
+/// * `f` The parser to apply.
+///
+/// *Note*: If the parser passed to `many1` accepts empty inputs
+/// (like `alpha0` or `digit0`), `many1` will return an error,
+/// to prevent going into an infinite loop.
+///
+/// ```rust
+/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
+/// use nom::multi::many1;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   many1(tag("abc"))(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
+/// ```
+#[cfg(feature = "alloc")]
+#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+pub fn many1<I, O, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  E: ParseError<I>,
+{
+  move |mut i: I| match f.parse(i.clone()) {
+    Err(Err::Error(err)) => Err(Err::Error(E::append(i, ErrorKind::Many1, err))),
+    Err(e) => Err(e),
+    Ok((i1, o)) => {
+      let mut acc = crate::lib::std::vec::Vec::with_capacity(4);
+      acc.push(o);
+      i = i1;
+
+      loop {
+        let len = i.input_len();
+        match f.parse(i.clone()) {
+          Err(Err::Error(_)) => return Ok((i, acc)),
+          Err(e) => return Err(e),
+          Ok((i1, o)) => {
+            // infinite loop check: the parser must always consume
+            if i1.input_len() == len {
+              return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1)));
+            }
+
+            i = i1;
+            acc.push(o);
+          }
+        }
+      }
+    }
+  }
+}
+
+/// Applies the parser `f` until the parser `g` produces a result.
+///
+/// Returns a tuple of the results of `f` in a `Vec` and the result of `g`.
+///
+/// `f` keeps going so long as `g` produces [`Err::Error`]. To instead chain an error up, see [`cut`][crate::combinator::cut].
+///
+/// ```rust
+/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
+/// use nom::multi::many_till;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, (Vec<&str>, &str)> {
+///   many_till(tag("abc"), tag("end"))(s)
+/// };
+///
+/// assert_eq!(parser("abcabcend"), Ok(("", (vec!["abc", "abc"], "end"))));
+/// assert_eq!(parser("abc123end"), Err(Err::Error(Error::new("123end", ErrorKind::Tag))));
+/// assert_eq!(parser("123123end"), Err(Err::Error(Error::new("123123end", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser("abcendefg"), Ok(("efg", (vec!["abc"], "end"))));
+/// ```
+#[cfg(feature = "alloc")]
+#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+pub fn many_till<I, O, P, E, F, G>(
+  mut f: F,
+  mut g: G,
+) -> impl FnMut(I) -> IResult<I, (Vec<O>, P), E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  G: Parser<I, P, E>,
+  E: ParseError<I>,
+{
+  move |mut i: I| {
+    let mut res = crate::lib::std::vec::Vec::new();
+    loop {
+      let len = i.input_len();
+      match g.parse(i.clone()) {
+        Ok((i1, o)) => return Ok((i1, (res, o))),
+        Err(Err::Error(_)) => {
+          match f.parse(i.clone()) {
+            Err(Err::Error(err)) => return Err(Err::Error(E::append(i, ErrorKind::ManyTill, err))),
+            Err(e) => return Err(e),
+            Ok((i1, o)) => {
+              // infinite loop check: the parser must always consume
+              if i1.input_len() == len {
+                return Err(Err::Error(E::from_error_kind(i1, ErrorKind::ManyTill)));
+              }
+
+              res.push(o);
+              i = i1;
+            }
+          }
+        }
+        Err(e) => return Err(e),
+      }
+    }
+  }
+}
+
+/// Alternates between two parsers to produce a list of elements.
+///
+/// This stops when either parser returns [`Err::Error`]  and returns the results that were accumulated. To instead chain an error up, see
+/// [`cut`][crate::combinator::cut].
+///
+/// # Arguments
+/// * `sep` Parses the separator between list elements.
+/// * `f` Parses the elements of the list.
+///
+/// ```rust
+/// # use nom::{Err, error::ErrorKind, Needed, IResult};
+/// use nom::multi::separated_list0;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   separated_list0(tag("|"), tag("abc"))(s)
+/// }
+///
+/// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"])));
+/// assert_eq!(parser("abc123abc"), Ok(("123abc", vec!["abc"])));
+/// assert_eq!(parser("abc|def"), Ok(("|def", vec!["abc"])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// assert_eq!(parser("def|abc"), Ok(("def|abc", vec![])));
+/// ```
+#[cfg(feature = "alloc")]
+#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+pub fn separated_list0<I, O, O2, E, F, G>(
+  mut sep: G,
+  mut f: F,
+) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  G: Parser<I, O2, E>,
+  E: ParseError<I>,
+{
+  move |mut i: I| {
+    let mut res = Vec::new();
+
+    match f.parse(i.clone()) {
+      Err(Err::Error(_)) => return Ok((i, res)),
+      Err(e) => return Err(e),
+      Ok((i1, o)) => {
+        res.push(o);
+        i = i1;
+      }
+    }
+
+    loop {
+      let len = i.input_len();
+      match sep.parse(i.clone()) {
+        Err(Err::Error(_)) => return Ok((i, res)),
+        Err(e) => return Err(e),
+        Ok((i1, _)) => {
+          // infinite loop check: the parser must always consume
+          if i1.input_len() == len {
+            return Err(Err::Error(E::from_error_kind(i1, ErrorKind::SeparatedList)));
+          }
+
+          match f.parse(i1.clone()) {
+            Err(Err::Error(_)) => return Ok((i, res)),
+            Err(e) => return Err(e),
+            Ok((i2, o)) => {
+              res.push(o);
+              i = i2;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/// Alternates between two parsers to produce a list of elements until [`Err::Error`].
+///
+/// Fails if the element parser does not produce at least one element.$
+///
+/// This stops when either parser returns [`Err::Error`]  and returns the results that were accumulated. To instead chain an error up, see
+/// [`cut`][crate::combinator::cut].
+///
+/// # Arguments
+/// * `sep` Parses the separator between list elements.
+/// * `f` Parses the elements of the list.
+/// ```rust
+/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
+/// use nom::multi::separated_list1;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   separated_list1(tag("|"), tag("abc"))(s)
+/// }
+///
+/// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"])));
+/// assert_eq!(parser("abc123abc"), Ok(("123abc", vec!["abc"])));
+/// assert_eq!(parser("abc|def"), Ok(("|def", vec!["abc"])));
+/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser("def|abc"), Err(Err::Error(Error::new("def|abc", ErrorKind::Tag))));
+/// ```
+#[cfg(feature = "alloc")]
+#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+pub fn separated_list1<I, O, O2, E, F, G>(
+  mut sep: G,
+  mut f: F,
+) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  G: Parser<I, O2, E>,
+  E: ParseError<I>,
+{
+  move |mut i: I| {
+    let mut res = Vec::new();
+
+    // Parse the first element
+    match f.parse(i.clone()) {
+      Err(e) => return Err(e),
+      Ok((i1, o)) => {
+        res.push(o);
+        i = i1;
+      }
+    }
+
+    loop {
+      let len = i.input_len();
+      match sep.parse(i.clone()) {
+        Err(Err::Error(_)) => return Ok((i, res)),
+        Err(e) => return Err(e),
+        Ok((i1, _)) => {
+          // infinite loop check: the parser must always consume
+          if i1.input_len() == len {
+            return Err(Err::Error(E::from_error_kind(i1, ErrorKind::SeparatedList)));
+          }
+
+          match f.parse(i1.clone()) {
+            Err(Err::Error(_)) => return Ok((i, res)),
+            Err(e) => return Err(e),
+            Ok((i2, o)) => {
+              res.push(o);
+              i = i2;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/// Repeats the embedded parser `m..=n` times
+///
+/// This stops before `n` when the parser returns [`Err::Error`]  and returns the results that were accumulated. To instead chain an error up, see
+/// [`cut`][crate::combinator::cut].
+///
+/// # Arguments
+/// * `m` The minimum number of iterations.
+/// * `n` The maximum number of iterations.
+/// * `f` The parser to apply.
+///
+/// *Note*: If the parser passed to `many1` accepts empty inputs
+/// (like `alpha0` or `digit0`), `many1` will return an error,
+/// to prevent going into an infinite loop.
+///
+/// ```rust
+/// # use nom::{Err, error::ErrorKind, Needed, IResult};
+/// use nom::multi::many_m_n;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   many_m_n(0, 2, tag("abc"))(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Ok(("123123", vec![])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
+/// ```
+#[cfg(feature = "alloc")]
+#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+pub fn many_m_n<I, O, E, F>(
+  min: usize,
+  max: usize,
+  mut parse: F,
+) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  E: ParseError<I>,
+{
+  move |mut input: I| {
+    if min > max {
+      return Err(Err::Failure(E::from_error_kind(input, ErrorKind::ManyMN)));
+    }
+
+    let max_initial_capacity =
+      MAX_INITIAL_CAPACITY_BYTES / crate::lib::std::mem::size_of::<O>().max(1);
+    let mut res = crate::lib::std::vec::Vec::with_capacity(min.min(max_initial_capacity));
+    for count in 0..max {
+      let len = input.input_len();
+      match parse.parse(input.clone()) {
+        Ok((tail, value)) => {
+          // infinite loop check: the parser must always consume
+          if tail.input_len() == len {
+            return Err(Err::Error(E::from_error_kind(input, ErrorKind::ManyMN)));
+          }
+
+          res.push(value);
+          input = tail;
+        }
+        Err(Err::Error(e)) => {
+          if count < min {
+            return Err(Err::Error(E::append(input, ErrorKind::ManyMN, e)));
+          } else {
+            return Ok((input, res));
+          }
+        }
+        Err(e) => {
+          return Err(e);
+        }
+      }
+    }
+
+    Ok((input, res))
+  }
+}
+
+/// Repeats the embedded parser, counting the results
+///
+/// This stops on [`Err::Error`]. To instead chain an error up, see
+/// [`cut`][crate::combinator::cut].
+///
+/// # Arguments
+/// * `f` The parser to apply.
+///
+/// *Note*: if the parser passed in accepts empty inputs (like `alpha0` or `digit0`), `many0` will
+/// return an error, to prevent going into an infinite loop
+///
+/// ```rust
+/// # use nom::{Err, error::ErrorKind, Needed, IResult};
+/// use nom::multi::many0_count;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, usize> {
+///   many0_count(tag("abc"))(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", 2)));
+/// assert_eq!(parser("abc123"), Ok(("123", 1)));
+/// assert_eq!(parser("123123"), Ok(("123123", 0)));
+/// assert_eq!(parser(""), Ok(("", 0)));
+/// ```
+pub fn many0_count<I, O, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, usize, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  E: ParseError<I>,
+{
+  move |i: I| {
+    let mut input = i;
+    let mut count = 0;
+
+    loop {
+      let input_ = input.clone();
+      let len = input.input_len();
+      match f.parse(input_) {
+        Ok((i, _)) => {
+          // infinite loop check: the parser must always consume
+          if i.input_len() == len {
+            return Err(Err::Error(E::from_error_kind(input, ErrorKind::Many0Count)));
+          }
+
+          input = i;
+          count += 1;
+        }
+
+        Err(Err::Error(_)) => return Ok((input, count)),
+
+        Err(e) => return Err(e),
+      }
+    }
+  }
+}
+
+/// Runs the embedded parser, counting the results.
+///
+/// This stops on [`Err::Error`] if there is at least one result. To instead chain an error up,
+/// see [`cut`][crate::combinator::cut].
+///
+/// # Arguments
+/// * `f` The parser to apply.
+///
+/// *Note*: If the parser passed to `many1` accepts empty inputs
+/// (like `alpha0` or `digit0`), `many1` will return an error,
+/// to prevent going into an infinite loop.
+///
+/// ```rust
+/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
+/// use nom::multi::many1_count;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, usize> {
+///   many1_count(tag("abc"))(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", 2)));
+/// assert_eq!(parser("abc123"), Ok(("123", 1)));
+/// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1Count))));
+/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1Count))));
+/// ```
+pub fn many1_count<I, O, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, usize, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  E: ParseError<I>,
+{
+  move |i: I| {
+    let i_ = i.clone();
+    match f.parse(i_) {
+      Err(Err::Error(_)) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1Count))),
+      Err(i) => Err(i),
+      Ok((i1, _)) => {
+        let mut count = 1;
+        let mut input = i1;
+
+        loop {
+          let len = input.input_len();
+          let input_ = input.clone();
+          match f.parse(input_) {
+            Err(Err::Error(_)) => return Ok((input, count)),
+            Err(e) => return Err(e),
+            Ok((i, _)) => {
+              // infinite loop check: the parser must always consume
+              if i.input_len() == len {
+                return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1Count)));
+              }
+
+              count += 1;
+              input = i;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/// Runs the embedded parser `count` times, gathering the results in a `Vec`
+///
+/// # Arguments
+/// * `f` The parser to apply.
+/// * `count` How often to apply the parser.
+/// ```rust
+/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
+/// use nom::multi::count;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   count(tag("abc"), 2)(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Err(Err::Error(Error::new("123", ErrorKind::Tag))));
+/// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
+/// ```
+#[cfg(feature = "alloc")]
+#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+pub fn count<I, O, E, F>(mut f: F, count: usize) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + PartialEq,
+  F: Parser<I, O, E>,
+  E: ParseError<I>,
+{
+  move |i: I| {
+    let mut input = i.clone();
+    let max_initial_capacity =
+      MAX_INITIAL_CAPACITY_BYTES / crate::lib::std::mem::size_of::<O>().max(1);
+    let mut res = crate::lib::std::vec::Vec::with_capacity(count.min(max_initial_capacity));
+
+    for _ in 0..count {
+      let input_ = input.clone();
+      match f.parse(input_) {
+        Ok((i, o)) => {
+          res.push(o);
+          input = i;
+        }
+        Err(Err::Error(e)) => {
+          return Err(Err::Error(E::append(i, ErrorKind::Count, e)));
+        }
+        Err(e) => {
+          return Err(e);
+        }
+      }
+    }
+
+    Ok((input, res))
+  }
+}
+
+/// Runs the embedded parser repeatedly, filling the given slice with results.
+///
+/// This parser fails if the input runs out before the given slice is full.
+///
+/// # Arguments
+/// * `f` The parser to apply.
+/// * `buf` The slice to fill
+/// ```rust
+/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
+/// use nom::multi::fill;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, [&str; 2]> {
+///   let mut buf = ["", ""];
+///   let (rest, ()) = fill(tag("abc"), &mut buf)(s)?;
+///   Ok((rest, buf))
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", ["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Err(Err::Error(Error::new("123", ErrorKind::Tag))));
+/// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser("abcabcabc"), Ok(("abc", ["abc", "abc"])));
+/// ```
+pub fn fill<'a, I, O, E, F>(f: F, buf: &'a mut [O]) -> impl FnMut(I) -> IResult<I, (), E> + 'a
+where
+  I: Clone + PartialEq,
+  F: Fn(I) -> IResult<I, O, E> + 'a,
+  E: ParseError<I>,
+{
+  move |i: I| {
+    let mut input = i.clone();
+
+    for elem in buf.iter_mut() {
+      let input_ = input.clone();
+      match f(input_) {
+        Ok((i, o)) => {
+          *elem = o;
+          input = i;
+        }
+        Err(Err::Error(e)) => {
+          return Err(Err::Error(E::append(i, ErrorKind::Count, e)));
+        }
+        Err(e) => {
+          return Err(e);
+        }
+      }
+    }
+
+    Ok((input, ()))
+  }
+}
+
+/// Repeats the embedded parser, calling `g` to gather the results.
+///
+/// This stops on [`Err::Error`]. To instead chain an error up, see
+/// [`cut`][crate::combinator::cut].
+///
+/// # Arguments
+/// * `f` The parser to apply.
+/// * `init` A function returning the initial value.
+/// * `g` The function that combines a result of `f` with
+///       the current accumulator.
+///
+/// *Note*: if the parser passed in accepts empty inputs (like `alpha0` or `digit0`), `many0` will
+/// return an error, to prevent going into an infinite loop
+///
+/// ```rust
+/// # use nom::{Err, error::ErrorKind, Needed, IResult};
+/// use nom::multi::fold_many0;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   fold_many0(
+///     tag("abc"),
+///     Vec::new,
+///     |mut acc: Vec<_>, item| {
+///       acc.push(item);
+///       acc
+///     }
+///   )(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Ok(("123123", vec![])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// ```
+pub fn fold_many0<I, O, E, F, G, H, R>(
+  mut f: F,
+  mut init: H,
+  mut g: G,
+) -> impl FnMut(I) -> IResult<I, R, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  G: FnMut(R, O) -> R,
+  H: FnMut() -> R,
+  E: ParseError<I>,
+{
+  move |i: I| {
+    let mut res = init();
+    let mut input = i;
+
+    loop {
+      let i_ = input.clone();
+      let len = input.input_len();
+      match f.parse(i_) {
+        Ok((i, o)) => {
+          // infinite loop check: the parser must always consume
+          if i.input_len() == len {
+            return Err(Err::Error(E::from_error_kind(input, ErrorKind::Many0)));
+          }
+
+          res = g(res, o);
+          input = i;
+        }
+        Err(Err::Error(_)) => {
+          return Ok((input, res));
+        }
+        Err(e) => {
+          return Err(e);
+        }
+      }
+    }
+  }
+}
+
+/// Repeats the embedded parser, calling `g` to gather the results.
+///
+/// This stops on [`Err::Error`] if there is at least one result. To instead chain an error up,
+/// see [`cut`][crate::combinator::cut].
+///
+/// # Arguments
+/// * `f` The parser to apply.
+/// * `init` A function returning the initial value.
+/// * `g` The function that combines a result of `f` with
+///       the current accumulator.
+///
+/// *Note*: If the parser passed to `many1` accepts empty inputs
+/// (like `alpha0` or `digit0`), `many1` will return an error,
+/// to prevent going into an infinite loop.
+///
+/// ```rust
+/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
+/// use nom::multi::fold_many1;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   fold_many1(
+///     tag("abc"),
+///     Vec::new,
+///     |mut acc: Vec<_>, item| {
+///       acc.push(item);
+///       acc
+///     }
+///   )(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1))));
+/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1))));
+/// ```
+pub fn fold_many1<I, O, E, F, G, H, R>(
+  mut f: F,
+  mut init: H,
+  mut g: G,
+) -> impl FnMut(I) -> IResult<I, R, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  G: FnMut(R, O) -> R,
+  H: FnMut() -> R,
+  E: ParseError<I>,
+{
+  move |i: I| {
+    let _i = i.clone();
+    let init = init();
+    match f.parse(_i) {
+      Err(Err::Error(_)) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1))),
+      Err(e) => Err(e),
+      Ok((i1, o1)) => {
+        let mut acc = g(init, o1);
+        let mut input = i1;
+
+        loop {
+          let _input = input.clone();
+          let len = input.input_len();
+          match f.parse(_input) {
+            Err(Err::Error(_)) => {
+              break;
+            }
+            Err(e) => return Err(e),
+            Ok((i, o)) => {
+              // infinite loop check: the parser must always consume
+              if i.input_len() == len {
+                return Err(Err::Failure(E::from_error_kind(i, ErrorKind::Many1)));
+              }
+
+              acc = g(acc, o);
+              input = i;
+            }
+          }
+        }
+
+        Ok((input, acc))
+      }
+    }
+  }
+}
+
+/// Repeats the embedded parser `m..=n` times, calling `g` to gather the results
+///
+/// This stops before `n` when the parser returns [`Err::Error`]. To instead chain an error up, see
+/// [`cut`][crate::combinator::cut].
+///
+/// # Arguments
+/// * `m` The minimum number of iterations.
+/// * `n` The maximum number of iterations.
+/// * `f` The parser to apply.
+/// * `init` A function returning the initial value.
+/// * `g` The function that combines a result of `f` with
+///       the current accumulator.
+///
+/// *Note*: If the parser passed to `many1` accepts empty inputs
+/// (like `alpha0` or `digit0`), `many1` will return an error,
+/// to prevent going into an infinite loop.
+///
+/// ```rust
+/// # use nom::{Err, error::ErrorKind, Needed, IResult};
+/// use nom::multi::fold_many_m_n;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   fold_many_m_n(
+///     0,
+///     2,
+///     tag("abc"),
+///     Vec::new,
+///     |mut acc: Vec<_>, item| {
+///       acc.push(item);
+///       acc
+///     }
+///   )(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Ok(("123123", vec![])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
+/// ```
+pub fn fold_many_m_n<I, O, E, F, G, H, R>(
+  min: usize,
+  max: usize,
+  mut parse: F,
+  mut init: H,
+  mut fold: G,
+) -> impl FnMut(I) -> IResult<I, R, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  G: FnMut(R, O) -> R,
+  H: FnMut() -> R,
+  E: ParseError<I>,
+{
+  move |mut input: I| {
+    if min > max {
+      return Err(Err::Failure(E::from_error_kind(input, ErrorKind::ManyMN)));
+    }
+
+    let mut acc = init();
+    for count in 0..max {
+      let len = input.input_len();
+      match parse.parse(input.clone()) {
+        Ok((tail, value)) => {
+          // infinite loop check: the parser must always consume
+          if tail.input_len() == len {
+            return Err(Err::Error(E::from_error_kind(tail, ErrorKind::ManyMN)));
+          }
+
+          acc = fold(acc, value);
+          input = tail;
+        }
+        //FInputXMError: handle failure properly
+        Err(Err::Error(err)) => {
+          if count < min {
+            return Err(Err::Error(E::append(input, ErrorKind::ManyMN, err)));
+          } else {
+            break;
+          }
+        }
+        Err(e) => return Err(e),
+      }
+    }
+
+    Ok((input, acc))
+  }
+}
+
+/// Gets a number from the parser and returns a
+/// subslice of the input of that size.
+/// If the parser returns `Incomplete`,
+/// `length_data` will return an error.
+/// # Arguments
+/// * `f` The parser to apply.
+/// ```rust
+/// # use nom::{Err, error::ErrorKind, Needed, IResult};
+/// use nom::number::complete::be_u16;
+/// use nom::multi::length_data;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], &[u8]> {
+///   length_data(be_u16)(s)
+/// }
+///
+/// assert_eq!(parser(b"\x00\x03abcefg"), Ok((&b"efg"[..], &b"abc"[..])));
+/// assert_eq!(parser(b"\x00\x03a"), Err(Err::Incomplete(Needed::new(2))));
+/// ```
+pub fn length_data<I, N, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, I, E>
+where
+  I: InputLength + InputTake,
+  N: ToUsize,
+  F: Parser<I, N, E>,
+  E: ParseError<I>,
+{
+  move |i: I| {
+    let (i, length) = f.parse(i)?;
+
+    let length: usize = length.to_usize();
+
+    if let Some(needed) = length
+      .checked_sub(i.input_len())
+      .and_then(NonZeroUsize::new)
+    {
+      Err(Err::Incomplete(Needed::Size(needed)))
+    } else {
+      Ok(i.take_split(length))
+    }
+  }
+}
+
+/// Gets a number from the first parser,
+/// takes a subslice of the input of that size,
+/// then applies the second parser on that subslice.
+/// If the second parser returns `Incomplete`,
+/// `length_value` will return an error.
+/// # Arguments
+/// * `f` The parser to apply.
+/// * `g` The parser to apply on the subslice.
+/// ```rust
+/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
+/// use nom::number::complete::be_u16;
+/// use nom::multi::length_value;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], &[u8]> {
+///   length_value(be_u16, tag("abc"))(s)
+/// }
+///
+/// assert_eq!(parser(b"\x00\x03abcefg"), Ok((&b"efg"[..], &b"abc"[..])));
+/// assert_eq!(parser(b"\x00\x03123123"), Err(Err::Error(Error::new(&b"123"[..], ErrorKind::Tag))));
+/// assert_eq!(parser(b"\x00\x03a"), Err(Err::Incomplete(Needed::new(2))));
+/// ```
+pub fn length_value<I, O, N, E, F, G>(mut f: F, mut g: G) -> impl FnMut(I) -> IResult<I, O, E>
+where
+  I: Clone + InputLength + InputTake,
+  N: ToUsize,
+  F: Parser<I, N, E>,
+  G: Parser<I, O, E>,
+  E: ParseError<I>,
+{
+  move |i: I| {
+    let (i, length) = f.parse(i)?;
+
+    let length: usize = length.to_usize();
+
+    if let Some(needed) = length
+      .checked_sub(i.input_len())
+      .and_then(NonZeroUsize::new)
+    {
+      Err(Err::Incomplete(Needed::Size(needed)))
+    } else {
+      let (rest, i) = i.take_split(length);
+      match g.parse(i.clone()) {
+        Err(Err::Incomplete(_)) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Complete))),
+        Err(e) => Err(e),
+        Ok((_, o)) => Ok((rest, o)),
+      }
+    }
+  }
+}
+
+/// Gets a number from the first parser,
+/// then applies the second parser that many times.
+/// # Arguments
+/// * `f` The parser to apply to obtain the count.
+/// * `g` The parser to apply repeatedly.
+/// ```rust
+/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
+/// use nom::number::complete::u8;
+/// use nom::multi::length_count;
+/// use nom::bytes::complete::tag;
+/// use nom::combinator::map;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+///   length_count(map(u8, |i| {
+///      println!("got number: {}", i);
+///      i
+///   }), tag("abc"))(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x02abcabcabc"[..]), Ok(((&b"abc"[..], vec![&b"abc"[..], &b"abc"[..]]))));
+/// assert_eq!(parser(b"\x03123123123"), Err(Err::Error(Error::new(&b"123123123"[..], ErrorKind::Tag))));
+/// ```
+#[cfg(feature = "alloc")]
+pub fn length_count<I, O, N, E, F, G>(mut f: F, mut g: G) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone,
+  N: ToUsize,
+  F: Parser<I, N, E>,
+  G: Parser<I, O, E>,
+  E: ParseError<I>,
+{
+  move |i: I| {
+    let (i, count) = f.parse(i)?;
+    let mut input = i.clone();
+    let mut res = Vec::new();
+
+    for _ in 0..count.to_usize() {
+      let input_ = input.clone();
+      match g.parse(input_) {
+        Ok((i, o)) => {
+          res.push(o);
+          input = i;
+        }
+        Err(Err::Error(e)) => {
+          return Err(Err::Error(E::append(i, ErrorKind::Count, e)));
+        }
+        Err(e) => {
+          return Err(e);
+        }
+      }
+    }
+
+    Ok((input, res))
+  }
+}
diff --git a/third_party/rust/nom/src/multi/tests.rs b/third_party/rust/nom/src/multi/tests.rs
new file mode 100644
index 0000000000..96a6518176
--- /dev/null
+++ b/third_party/rust/nom/src/multi/tests.rs
@@ -0,0 +1,534 @@
+use super::{length_data, length_value, many0_count, many1_count};
+use crate::{
+  bytes::streaming::tag,
+  character::streaming::digit1 as digit,
+  error::{ErrorKind, ParseError},
+  internal::{Err, IResult, Needed},
+  lib::std::str::{self, FromStr},
+  number::streaming::{be_u16, be_u8},
+  sequence::{pair, tuple},
+};
+#[cfg(feature = "alloc")]
+use crate::{
+  lib::std::vec::Vec,
+  multi::{
+    count, fold_many0, fold_many1, fold_many_m_n, length_count, many0, many1, many_m_n, many_till,
+    separated_list0, separated_list1,
+  },
+};
+
+#[test]
+#[cfg(feature = "alloc")]
+fn separated_list0_test() {
+  fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    separated_list0(tag(","), tag("abcd"))(i)
+  }
+  fn multi_empty(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    separated_list0(tag(","), tag(""))(i)
+  }
+  fn empty_sep(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    separated_list0(tag(""), tag("abc"))(i)
+  }
+  fn multi_longsep(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    separated_list0(tag(".."), tag("abcd"))(i)
+  }
+
+  let a = &b"abcdef"[..];
+  let b = &b"abcd,abcdef"[..];
+  let c = &b"azerty"[..];
+  let d = &b",,abc"[..];
+  let e = &b"abcd,abcd,ef"[..];
+  let f = &b"abc"[..];
+  let g = &b"abcd."[..];
+  let h = &b"abcd,abc"[..];
+  let i = &b"abcabc"[..];
+
+  let res1 = vec![&b"abcd"[..]];
+  assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
+  let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
+  assert_eq!(multi(b), Ok((&b"ef"[..], res2)));
+  assert_eq!(multi(c), Ok((&b"azerty"[..], Vec::new())));
+  let res3 = vec![&b""[..], &b""[..], &b""[..]];
+  assert_eq!(multi_empty(d), Ok((&b"abc"[..], res3)));
+  let i_err_pos = &i[3..];
+  assert_eq!(
+    empty_sep(i),
+    Err(Err::Error(error_position!(
+      i_err_pos,
+      ErrorKind::SeparatedList
+    )))
+  );
+  let res4 = vec![&b"abcd"[..], &b"abcd"[..]];
+  assert_eq!(multi(e), Ok((&b",ef"[..], res4)));
+
+  assert_eq!(multi(f), Err(Err::Incomplete(Needed::new(1))));
+  assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::new(1))));
+  assert_eq!(multi(h), Err(Err::Incomplete(Needed::new(1))));
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn separated_list1_test() {
+  fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    separated_list1(tag(","), tag("abcd"))(i)
+  }
+  fn multi_longsep(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    separated_list1(tag(".."), tag("abcd"))(i)
+  }
+
+  let a = &b"abcdef"[..];
+  let b = &b"abcd,abcdef"[..];
+  let c = &b"azerty"[..];
+  let d = &b"abcd,abcd,ef"[..];
+
+  let f = &b"abc"[..];
+  let g = &b"abcd."[..];
+  let h = &b"abcd,abc"[..];
+
+  let res1 = vec![&b"abcd"[..]];
+  assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
+  let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
+  assert_eq!(multi(b), Ok((&b"ef"[..], res2)));
+  assert_eq!(
+    multi(c),
+    Err(Err::Error(error_position!(c, ErrorKind::Tag)))
+  );
+  let res3 = vec![&b"abcd"[..], &b"abcd"[..]];
+  assert_eq!(multi(d), Ok((&b",ef"[..], res3)));
+
+  assert_eq!(multi(f), Err(Err::Incomplete(Needed::new(1))));
+  assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::new(1))));
+  assert_eq!(multi(h), Err(Err::Incomplete(Needed::new(1))));
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn many0_test() {
+  fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    many0(tag("abcd"))(i)
+  }
+  fn multi_empty(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    many0(tag(""))(i)
+  }
+
+  assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]])));
+  assert_eq!(
+    multi(&b"abcdabcdefgh"[..]),
+    Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))
+  );
+  assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new())));
+  assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::new(2))));
+  assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(4))));
+  assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::new(4))));
+  assert_eq!(
+    multi_empty(&b"abcdef"[..]),
+    Err(Err::Error(error_position!(
+      &b"abcdef"[..],
+      ErrorKind::Many0
+    )))
+  );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn many1_test() {
+  fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    many1(tag("abcd"))(i)
+  }
+
+  let a = &b"abcdef"[..];
+  let b = &b"abcdabcdefgh"[..];
+  let c = &b"azerty"[..];
+  let d = &b"abcdab"[..];
+
+  let res1 = vec![&b"abcd"[..]];
+  assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
+  let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
+  assert_eq!(multi(b), Ok((&b"efgh"[..], res2)));
+  assert_eq!(
+    multi(c),
+    Err(Err::Error(error_position!(c, ErrorKind::Tag)))
+  );
+  assert_eq!(multi(d), Err(Err::Incomplete(Needed::new(2))));
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn many_till_test() {
+  fn multi(i: &[u8]) -> IResult<&[u8], (Vec<&[u8]>, &[u8])> {
+    many_till(tag("abcd"), tag("efgh"))(i)
+  }
+
+  let a = b"abcdabcdefghabcd";
+  let b = b"efghabcd";
+  let c = b"azerty";
+
+  let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]);
+  let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]);
+  assert_eq!(multi(&a[..]), Ok((&b"abcd"[..], res_a)));
+  assert_eq!(multi(&b[..]), Ok((&b"abcd"[..], res_b)));
+  assert_eq!(
+    multi(&c[..]),
+    Err(Err::Error(error_node_position!(
+      &c[..],
+      ErrorKind::ManyTill,
+      error_position!(&c[..], ErrorKind::Tag)
+    )))
+  );
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn infinite_many() {
+  fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
+    println!("input: {:?}", input);
+    Err(Err::Error(error_position!(input, ErrorKind::Tag)))
+  }
+
+  // should not go into an infinite loop
+  fn multi0(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    many0(tst)(i)
+  }
+  let a = &b"abcdef"[..];
+  assert_eq!(multi0(a), Ok((a, Vec::new())));
+
+  fn multi1(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    many1(tst)(i)
+  }
+  let a = &b"abcdef"[..];
+  assert_eq!(
+    multi1(a),
+    Err(Err::Error(error_position!(a, ErrorKind::Tag)))
+  );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn many_m_n_test() {
+  fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    many_m_n(2, 4, tag("Abcd"))(i)
+  }
+
+  let a = &b"Abcdef"[..];
+  let b = &b"AbcdAbcdefgh"[..];
+  let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
+  let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
+  let e = &b"AbcdAb"[..];
+
+  assert_eq!(
+    multi(a),
+    Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
+  );
+  let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
+  assert_eq!(multi(b), Ok((&b"efgh"[..], res1)));
+  let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
+  assert_eq!(multi(c), Ok((&b"efgh"[..], res2)));
+  let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
+  assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3)));
+  assert_eq!(multi(e), Err(Err::Incomplete(Needed::new(2))));
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn count_test() {
+  const TIMES: usize = 2;
+  fn cnt_2(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    count(tag("abc"), TIMES)(i)
+  }
+
+  assert_eq!(
+    cnt_2(&b"abcabcabcdef"[..]),
+    Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]))
+  );
+  assert_eq!(cnt_2(&b"ab"[..]), Err(Err::Incomplete(Needed::new(1))));
+  assert_eq!(cnt_2(&b"abcab"[..]), Err(Err::Incomplete(Needed::new(1))));
+  assert_eq!(
+    cnt_2(&b"xxx"[..]),
+    Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
+  );
+  assert_eq!(
+    cnt_2(&b"xxxabcabcdef"[..]),
+    Err(Err::Error(error_position!(
+      &b"xxxabcabcdef"[..],
+      ErrorKind::Tag
+    )))
+  );
+  assert_eq!(
+    cnt_2(&b"abcxxxabcdef"[..]),
+    Err(Err::Error(error_position!(
+      &b"xxxabcdef"[..],
+      ErrorKind::Tag
+    )))
+  );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn count_zero() {
+  const TIMES: usize = 0;
+  fn counter_2(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    count(tag("abc"), TIMES)(i)
+  }
+
+  let done = &b"abcabcabcdef"[..];
+  let parsed_done = Vec::new();
+  let rest = done;
+  let incomplete_1 = &b"ab"[..];
+  let parsed_incompl_1 = Vec::new();
+  let incomplete_2 = &b"abcab"[..];
+  let parsed_incompl_2 = Vec::new();
+  let error = &b"xxx"[..];
+  let error_remain = &b"xxx"[..];
+  let parsed_err = Vec::new();
+  let error_1 = &b"xxxabcabcdef"[..];
+  let parsed_err_1 = Vec::new();
+  let error_1_remain = &b"xxxabcabcdef"[..];
+  let error_2 = &b"abcxxxabcdef"[..];
+  let parsed_err_2 = Vec::new();
+  let error_2_remain = &b"abcxxxabcdef"[..];
+
+  assert_eq!(counter_2(done), Ok((rest, parsed_done)));
+  assert_eq!(
+    counter_2(incomplete_1),
+    Ok((incomplete_1, parsed_incompl_1))
+  );
+  assert_eq!(
+    counter_2(incomplete_2),
+    Ok((incomplete_2, parsed_incompl_2))
+  );
+  assert_eq!(counter_2(error), Ok((error_remain, parsed_err)));
+  assert_eq!(counter_2(error_1), Ok((error_1_remain, parsed_err_1)));
+  assert_eq!(counter_2(error_2), Ok((error_2_remain, parsed_err_2)));
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct NilError;
+
+impl<I> From<(I, ErrorKind)> for NilError {
+  fn from(_: (I, ErrorKind)) -> Self {
+    NilError
+  }
+}
+
+impl<I> ParseError<I> for NilError {
+  fn from_error_kind(_: I, _: ErrorKind) -> NilError {
+    NilError
+  }
+  fn append(_: I, _: ErrorKind, _: NilError) -> NilError {
+    NilError
+  }
+}
+
+fn number(i: &[u8]) -> IResult<&[u8], u32> {
+  use crate::combinator::map_res;
+
+  map_res(map_res(digit, str::from_utf8), FromStr::from_str)(i)
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn length_count_test() {
+  fn cnt(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    length_count(number, tag("abc"))(i)
+  }
+
+  assert_eq!(
+    cnt(&b"2abcabcabcdef"[..]),
+    Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]))
+  );
+  assert_eq!(cnt(&b"2ab"[..]), Err(Err::Incomplete(Needed::new(1))));
+  assert_eq!(cnt(&b"3abcab"[..]), Err(Err::Incomplete(Needed::new(1))));
+  assert_eq!(
+    cnt(&b"xxx"[..]),
+    Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit)))
+  );
+  assert_eq!(
+    cnt(&b"2abcxxx"[..]),
+    Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
+  );
+}
+
+#[test]
+fn length_data_test() {
+  fn take(i: &[u8]) -> IResult<&[u8], &[u8]> {
+    length_data(number)(i)
+  }
+
+  assert_eq!(
+    take(&b"6abcabcabcdef"[..]),
+    Ok((&b"abcdef"[..], &b"abcabc"[..]))
+  );
+  assert_eq!(take(&b"3ab"[..]), Err(Err::Incomplete(Needed::new(1))));
+  assert_eq!(
+    take(&b"xxx"[..]),
+    Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit)))
+  );
+  assert_eq!(take(&b"2abcxxx"[..]), Ok((&b"cxxx"[..], &b"ab"[..])));
+}
+
+#[test]
+fn length_value_test() {
+  fn length_value_1(i: &[u8]) -> IResult<&[u8], u16> {
+    length_value(be_u8, be_u16)(i)
+  }
+  fn length_value_2(i: &[u8]) -> IResult<&[u8], (u8, u8)> {
+    length_value(be_u8, tuple((be_u8, be_u8)))(i)
+  }
+
+  let i1 = [0, 5, 6];
+  assert_eq!(
+    length_value_1(&i1),
+    Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete)))
+  );
+  assert_eq!(
+    length_value_2(&i1),
+    Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete)))
+  );
+
+  let i2 = [1, 5, 6, 3];
+  assert_eq!(
+    length_value_1(&i2),
+    Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete)))
+  );
+  assert_eq!(
+    length_value_2(&i2),
+    Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete)))
+  );
+
+  let i3 = [2, 5, 6, 3, 4, 5, 7];
+  assert_eq!(length_value_1(&i3), Ok((&i3[3..], 1286)));
+  assert_eq!(length_value_2(&i3), Ok((&i3[3..], (5, 6))));
+
+  let i4 = [3, 5, 6, 3, 4, 5];
+  assert_eq!(length_value_1(&i4), Ok((&i4[4..], 1286)));
+  assert_eq!(length_value_2(&i4), Ok((&i4[4..], (5, 6))));
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn fold_many0_test() {
+  fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
+    acc.push(item);
+    acc
+  }
+  fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    fold_many0(tag("abcd"), Vec::new, fold_into_vec)(i)
+  }
+  fn multi_empty(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    fold_many0(tag(""), Vec::new, fold_into_vec)(i)
+  }
+
+  assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]])));
+  assert_eq!(
+    multi(&b"abcdabcdefgh"[..]),
+    Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))
+  );
+  assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new())));
+  assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::new(2))));
+  assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(4))));
+  assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::new(4))));
+  assert_eq!(
+    multi_empty(&b"abcdef"[..]),
+    Err(Err::Error(error_position!(
+      &b"abcdef"[..],
+      ErrorKind::Many0
+    )))
+  );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn fold_many1_test() {
+  fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
+    acc.push(item);
+    acc
+  }
+  fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    fold_many1(tag("abcd"), Vec::new, fold_into_vec)(i)
+  }
+
+  let a = &b"abcdef"[..];
+  let b = &b"abcdabcdefgh"[..];
+  let c = &b"azerty"[..];
+  let d = &b"abcdab"[..];
+
+  let res1 = vec![&b"abcd"[..]];
+  assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
+  let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
+  assert_eq!(multi(b), Ok((&b"efgh"[..], res2)));
+  assert_eq!(
+    multi(c),
+    Err(Err::Error(error_position!(c, ErrorKind::Many1)))
+  );
+  assert_eq!(multi(d), Err(Err::Incomplete(Needed::new(2))));
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn fold_many_m_n_test() {
+  fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
+    acc.push(item);
+    acc
+  }
+  fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+    fold_many_m_n(2, 4, tag("Abcd"), Vec::new, fold_into_vec)(i)
+  }
+
+  let a = &b"Abcdef"[..];
+  let b = &b"AbcdAbcdefgh"[..];
+  let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
+  let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
+  let e = &b"AbcdAb"[..];
+
+  assert_eq!(
+    multi(a),
+    Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
+  );
+  let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
+  assert_eq!(multi(b), Ok((&b"efgh"[..], res1)));
+  let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
+  assert_eq!(multi(c), Ok((&b"efgh"[..], res2)));
+  let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
+  assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3)));
+  assert_eq!(multi(e), Err(Err::Incomplete(Needed::new(2))));
+}
+
+#[test]
+fn many0_count_test() {
+  fn count0_nums(i: &[u8]) -> IResult<&[u8], usize> {
+    many0_count(pair(digit, tag(",")))(i)
+  }
+
+  assert_eq!(count0_nums(&b"123,junk"[..]), Ok((&b"junk"[..], 1)));
+
+  assert_eq!(count0_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
+
+  assert_eq!(
+    count0_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
+    Ok((&b"junk"[..], 10))
+  );
+
+  assert_eq!(count0_nums(&b"hello"[..]), Ok((&b"hello"[..], 0)));
+}
+
+#[test]
+fn many1_count_test() {
+  fn count1_nums(i: &[u8]) -> IResult<&[u8], usize> {
+    many1_count(pair(digit, tag(",")))(i)
+  }
+
+  assert_eq!(count1_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
+
+  assert_eq!(
+    count1_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
+    Ok((&b"junk"[..], 10))
+  );
+
+  assert_eq!(
+    count1_nums(&b"hello"[..]),
+    Err(Err::Error(error_position!(
+      &b"hello"[..],
+      ErrorKind::Many1Count
+    )))
+  );
+}