DeCarabas/oden
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Vendor things

Browse source
This commit is contained in:
John Doty 2024-03-08 11:03:01 -08:00
parent 5deceec006
commit 977e3c17e5
19434 changed files with 10682014 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

1
third-party/vendor/matchers/.cargo-checksum.json vendored Normal file
View file

@ -0,0 +1 @@
{"files":{"CHANGELOG.md":"f022c90a4ed11b34fdd2e096aee16481f801bbc98d268301ec6cdd2630b46a2c","Cargo.toml":"30f617fcf19c44854f1408b284fa2df88ecf1d737714969f5bcf473ffab42e77","LICENSE":"a47129d738752a6ae52247fea645b42cb320d19e9327f1eb2d1a7f99d9455ad3","README.md":"e28e7f394422678115cfd9389c94ed2dd3c9eeeb1d71385f332cd52ab4581358","src/lib.rs":"5dac491ddc2e2240a2635a071bcaeca179f8bed86b411f0d27fa6a93bd8730ea"},"package":"8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"}

26
third-party/vendor/matchers/CHANGELOG.md vendored Normal file
View file

@ -0,0 +1,26 @@
<a name="0.1.0"></a>
## 0.1.0 (2021-02-25)
#### Features
* **Pattern:** add `Pattern::new_anchored` (#2) ([81f4c1c0](https://github.com/hawkw/matchers/commit/81f4c1c0ece4908d2e62607bb8a5690646404dec))
<a name="0.0.1"></a>
## 0.0.1 (2019-08-02)
#### Features
* add `FromStr` impl for `Pattern` ([86a33462](https://github.com/hawkw/matchers/commit/86a33462d80c48cf3d534da0759d2b2ea5ddce5f))
* add `Clone` and `Debug` impls ([9092305d](https://github.com/hawkw/matchers/commit/9092305dde81b69f1051b138b94f653124da662f))
* support matching on `io::Read` ([121efb9b](https://github.com/hawkw/matchers/commit/121efb9b093b817d6c67d11a5b5508079091ab3d))
#### Bug Fixes
* only short-circuit when known not to match ([71544493](https://github.com/hawkw/matchers/commit/71544493613049009f33f4885a1287eee0f21aa4))

29
third-party/vendor/matchers/Cargo.toml vendored Normal file
View file

@ -0,0 +1,29 @@
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
#
# When uploading crates to the registry Cargo will automatically
# "normalize" Cargo.toml files for maximal compatibility
# with all versions of Cargo and also rewrite `path` dependencies
# to registry (e.g., crates.io) dependencies
#
# If you believe there's an error in this file please file an
# issue against the rust-lang/cargo repository. If you're
# editing this file be aware that the upstream Cargo.toml
# will likely look very different (and much more reasonable)
[package]
edition = "2018"
name = "matchers"
version = "0.1.0"
authors = ["Eliza Weisman <eliza@buoyant.io>"]
description = "Regex matching on character and byte streams.\n"
homepage = "https://github.com/hawkw/matchers"
documentation = "https://docs.rs/matchers/"
readme = "README.md"
keywords = ["regex", "match", "pattern", "streaming"]
categories = ["text-processing"]
license = "MIT"
repository = "https://github.com/hawkw/matchers"
[dependencies.regex-automata]
version = "0.1"
[badges.maintenance]
status = "experimental"

19
third-party/vendor/matchers/LICENSE vendored Normal file
View file

@ -0,0 +1,19 @@
Copyright (c) 2019 Eliza Weisman
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

38
third-party/vendor/matchers/README.md vendored Normal file
View file

@ -0,0 +1,38 @@
# matchers
Regular expression matching on Rust streams.
[![Crates.io][crates-badge]][crates-url]
[![Documentation][docs-badge]][docs-url]
[![MIT licensed][mit-badge]][mit-url]
[![CI][ci-badge]][ci-url]
[crates-badge]: https://img.shields.io/crates/v/matchers.svg
[crates-url]: https://crates.io/crates/matchers
[docs-badge]: https://docs.rs/matchers/badge.svg
[docs-url]: https://docs.rs/matchers/0.1.0
[mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg
[mit-url]: LICENSE
[ci-badge]: https://github.com/hawkw/matchers/actions/workflows/ci.yml/badge.svg
[ci-url]: https://github.com/hawkw/matchers/actions/workflows/ci.yml
## Overview
The [`regex`] crate implements regular expression matching on strings and byte
arrays. However, in order to match the output of implementations of `fmt::Debug`
and `fmt::Display`, or by any code which writes to an instance of `fmt::Write`
or `io::Write`, it is necessary to first allocate a buffer, write to that
buffer, and then match the buffer against a regex.
In cases where it is not necessary to extract substrings, but only to test whether
or not output matches a regex, it is not strictly necessary to allocate and
write this output to a buffer. This crate provides a simple interface on top of
the lower-level [`regex-automata`] library that implements `fmt::Write` and
`io::Write` for regex patterns. This may be used to test whether streaming
output matches a pattern without buffering that output.
Users who need to extract substrings based on a pattern or who already have
buffered data should probably use the [`regex`] crate instead.
[`regex`]: https://crates.io/crates/regex
[`regex-automata`]: https://crates.io/crates/regex-automata

600
third-party/vendor/matchers/src/lib.rs vendored Normal file
View file

@ -0,0 +1,600 @@
//! Regex matchers on character and byte streams.
//!
//! ## Overview
//!
//! The [`regex`] crate implements regular expression matching on strings and byte
//! arrays. However, in order to match the output of implementations of `fmt::Debug`
//! and `fmt::Display`, or by any code which writes to an instance of `fmt::Write`
//! or `io::Write`, it is necessary to first allocate a buffer, write to that
//! buffer, and then match the buffer against a regex.
//!
//! In cases where it is not necessary to extract substrings, but only to test whether
//! or not output matches a regex, it is not strictly necessary to allocate and
//! write this output to a buffer. This crate provides a simple interface on top of
//! the lower-level [`regex-automata`] library that implements `fmt::Write` and
//! `io::Write` for regex patterns. This may be used to test whether streaming
//! output matches a pattern without buffering that output.
//!
//! Users who need to extract substrings based on a pattern or who already have
//! buffered data should probably use the [`regex`] crate instead.
//!
//! ## Syntax
//!
//! This crate uses the same [regex syntax][syntax] of the `regex-automata` crate.
//!
//! [`regex`]: https://crates.io/crates/regex
//! [`regex-automata`]: https://crates.io/crates/regex-automata
//! [syntax]: https://docs.rs/regex-automata/0.1.7/regex_automata/#syntax
use regex_automata::{dense, DenseDFA, SparseDFA, StateID, DFA};
use std::{fmt, io, marker::PhantomData, str::FromStr};
pub use regex_automata::Error;
/// A compiled match pattern that can match multipe inputs, or return a
/// [`Matcher`] that matches a single input.
///
/// [`Matcher`]: ../struct.Matcher.html
#[derive(Debug, Clone)]
pub struct Pattern<S = usize, A = DenseDFA<Vec<S>, S>>
where
S: StateID,
A: DFA<ID = S>,
{
automaton: A,
}
/// A reference to a [`Pattern`] that matches a single input.
///
/// [`Pattern`]: ../struct.Pattern.html
#[derive(Debug, Clone)]
pub struct Matcher<'a, S = usize, A = DenseDFA<&'a [S], S>>
where
S: StateID,
A: DFA<ID = S>,
{
automaton: A,
state: S,
_lt: PhantomData<&'a ()>,
}
// === impl Pattern ===
impl Pattern {
/// Returns a new `Pattern` for the given regex, or an error if the regex
/// was invalid.
///
/// The returned `Pattern` will match occurances of the pattern which start
/// at *any* in a byte or character stream — the pattern may be preceded by
/// any number of non-matching characters. Essentially, it will behave as
/// though the regular expression started with a `.*?`, which enables a
/// match to appear anywhere. If this is not the desired behavior, use
/// [`Pattern::new_anchored`] instead.
///
/// For example:
/// ```
/// use matchers::Pattern;
///
/// // This pattern matches any number of `a`s followed by a `b`.
/// let pattern = Pattern::new("a+b").expect("regex is not invalid");
///
/// // Of course, the pattern matches an input where the entire sequence of
/// // characters matches the pattern:
/// assert!(pattern.display_matches(&"aaaaab"));
///
/// // And, since the pattern is unanchored, it will also match the
/// // sequence when it's followed by non-matching characters:
/// assert!(pattern.display_matches(&"hello world! aaaaab"));
/// ```
pub fn new(pattern: &str) -> Result<Self, Error> {
let automaton = DenseDFA::new(pattern)?;
Ok(Pattern { automaton })
}
/// Returns a new `Pattern` anchored at the beginning of the input stream,
/// or an error if the regex was invalid.
///
/// The returned `Pattern` will *only* match an occurence of the pattern in
/// an input sequence if the first character or byte in the input matches
/// the pattern. If this is not the desired behavior, use [`Pattern::new`]
/// instead.
///
/// For example:
/// ```
/// use matchers::Pattern;
///
/// // This pattern matches any number of `a`s followed by a `b`.
/// let pattern = Pattern::new_anchored("a+b")
/// .expect("regex is not invalid");
///
/// // The pattern matches an input where the entire sequence of
/// // characters matches the pattern:
/// assert!(pattern.display_matches(&"aaaaab"));
///
/// // Since the pattern is anchored, it will *not* match an input that
/// // begins with non-matching characters:
/// assert!(!pattern.display_matches(&"hello world! aaaaab"));
///
/// // ...however, if we create a pattern beginning with `.*?`, it will:
/// let pattern2 = Pattern::new_anchored(".*?a+b")
/// .expect("regex is not invalid");
/// assert!(pattern2.display_matches(&"hello world! aaaaab"));
/// ```
pub fn new_anchored(pattern: &str) -> Result<Self, Error> {
let automaton = dense::Builder::new().anchored(true).build(pattern)?;
Ok(Pattern { automaton })
}
}
impl FromStr for Pattern {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::new(s)
}
}
impl<S, A> Pattern<S, A>
where
S: StateID,
A: DFA<ID = S>,
Self: for<'a> ToMatcher<'a, S>,
{
/// Returns `true` if this pattern matches the given string.
#[inline]
pub fn matches(&self, s: &impl AsRef<str>) -> bool {
self.matcher().matches(s)
}
/// Returns `true` if this pattern matches the formatted output of the given
/// type implementing `fmt::Debug`.
///
/// For example:
/// ```rust
/// use matchers::Pattern;
///
/// #[derive(Debug)]
/// pub struct Hello {
/// to: &'static str,
/// }
///
/// let pattern = Pattern::new(r#"Hello \{ to: "W[^"]*" \}"#).unwrap();
///
/// let hello_world = Hello { to: "World" };
/// assert!(pattern.debug_matches(&hello_world));
///
/// let hello_sf = Hello { to: "San Francisco" };
/// assert_eq!(pattern.debug_matches(&hello_sf), false);
///
/// let hello_washington = Hello { to: "Washington" };
/// assert!(pattern.debug_matches(&hello_washington));
/// ```
#[inline]
pub fn debug_matches(&self, d: &impl fmt::Debug) -> bool {
self.matcher().debug_matches(d)
}
/// Returns `true` if this pattern matches the formatted output of the given
/// type implementing `fmt::Display`.
///
/// For example:
/// ```rust
/// # use std::fmt;
/// use matchers::Pattern;
///
/// #[derive(Debug)]
/// pub struct Hello {
/// to: &'static str,
/// }
///
/// impl fmt::Display for Hello {
/// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
/// write!(f, "Hello {}", self.to)
/// }
/// }
///
/// let pattern = Pattern::new("Hello [Ww].+").unwrap();
///
/// let hello_world = Hello { to: "world" };
/// assert!(pattern.display_matches(&hello_world));
/// assert_eq!(pattern.debug_matches(&hello_world), false);
///
/// let hello_sf = Hello { to: "San Francisco" };
/// assert_eq!(pattern.display_matches(&hello_sf), false);
///
/// let hello_washington = Hello { to: "Washington" };
/// assert!(pattern.display_matches(&hello_washington));
/// ```
#[inline]
pub fn display_matches(&self, d: &impl fmt::Display) -> bool {
self.matcher().display_matches(d)
}
/// Returns either a `bool` indicating whether or not this pattern matches the
/// data read from the provided `io::Read` stream, or an `io::Error` if an
/// error occurred reading from the stream.
#[inline]
pub fn read_matches(&self, io: impl io::Read) -> io::Result<bool> {
self.matcher().read_matches(io)
}
}
// === impl Matcher ===
impl<'a, S, A> Matcher<'a, S, A>
where
S: StateID,
A: DFA<ID = S>,
{
fn new(automaton: A) -> Self {
let state = automaton.start_state();
Self {
automaton,
state,
_lt: PhantomData,
}
}
#[inline]
fn advance(&mut self, input: u8) {
self.state = unsafe {
// It's safe to call `next_state_unchecked` since the matcher may
// only be constructed by a `Pattern`, which, in turn,can only be
// constructed with a valid DFA.
self.automaton.next_state_unchecked(self.state, input)
};
}
/// Returns `true` if this `Matcher` has matched any input that has been
/// provided.
#[inline]
pub fn is_matched(&self) -> bool {
self.automaton.is_match_state(self.state)
}
/// Returns `true` if this pattern matches the formatted output of the given
/// type implementing `fmt::Debug`.
pub fn matches(mut self, s: &impl AsRef<str>) -> bool {
for &byte in s.as_ref().as_bytes() {
self.advance(byte);
if self.automaton.is_dead_state(self.state) {
return false;
}
}
self.is_matched()
}
/// Returns `true` if this pattern matches the formatted output of the given
/// type implementing `fmt::Debug`.
pub fn debug_matches(mut self, d: &impl fmt::Debug) -> bool {
use std::fmt::Write;
write!(&mut self, "{:?}", d).expect("matcher write impl should not fail");
self.is_matched()
}
/// Returns `true` if this pattern matches the formatted output of the given
/// type implementing `fmt::Display`.
pub fn display_matches(mut self, d: &impl fmt::Display) -> bool {
use std::fmt::Write;
write!(&mut self, "{}", d).expect("matcher write impl should not fail");
self.is_matched()
}
/// Returns either a `bool` indicating whether or not this pattern matches the
/// data read from the provided `io::Read` stream, or an `io::Error` if an
/// error occurred reading from the stream.
pub fn read_matches(mut self, io: impl io::Read + Sized) -> io::Result<bool> {
for r in io.bytes() {
self.advance(r?);
if self.automaton.is_dead_state(self.state) {
return Ok(false);
}
}
Ok(self.is_matched())
}
}
impl<'a, S, A> fmt::Write for Matcher<'a, S, A>
where
S: StateID,
A: DFA<ID = S>,
{
fn write_str(&mut self, s: &str) -> fmt::Result {
for &byte in s.as_bytes() {
self.advance(byte);
if self.automaton.is_dead_state(self.state) {
break;
}
}
Ok(())
}
}
impl<'a, S, A> io::Write for Matcher<'a, S, A>
where
S: StateID,
A: DFA<ID = S>,
{
fn write(&mut self, bytes: &[u8]) -> Result<usize, io::Error> {
let mut i = 0;
for &byte in bytes {
self.advance(byte);
i += 1;
if self.automaton.is_dead_state(self.state) {
break;
}
}
Ok(i)
}
fn flush(&mut self) -> Result<(), io::Error> {
Ok(())
}
}
pub trait ToMatcher<'a, S>
where
Self: crate::sealed::Sealed,
S: StateID + 'a,
{
type Automaton: DFA<ID = S>;
fn matcher(&'a self) -> Matcher<'a, S, Self::Automaton>;
}
impl<S> crate::sealed::Sealed for Pattern<S, DenseDFA<Vec<S>, S>> where S: StateID {}
impl<'a, S> ToMatcher<'a, S> for Pattern<S, DenseDFA<Vec<S>, S>>
where
S: StateID + 'a,
{
type Automaton = DenseDFA<&'a [S], S>;
fn matcher(&'a self) -> Matcher<'a, S, Self::Automaton> {
Matcher::new(self.automaton.as_ref())
}
}
impl<'a, S> ToMatcher<'a, S> for Pattern<S, SparseDFA<Vec<u8>, S>>
where
S: StateID + 'a,
{
type Automaton = SparseDFA<&'a [u8], S>;
fn matcher(&'a self) -> Matcher<'a, S, Self::Automaton> {
Matcher::new(self.automaton.as_ref())
}
}
impl<S> crate::sealed::Sealed for Pattern<S, SparseDFA<Vec<u8>, S>> where S: StateID {}
mod sealed {
pub trait Sealed {}
}
#[cfg(test)]
mod test {
use super::*;
struct Str<'a>(&'a str);
struct ReadStr<'a>(io::Cursor<&'a [u8]>);
impl<'a> fmt::Debug for Str<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl<'a> fmt::Display for Str<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl<'a> io::Read for ReadStr<'a> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.0.read(buf)
}
}
impl Str<'static> {
fn hello_world() -> Self {
Self::new("hello world")
}
}
impl<'a> Str<'a> {
fn new(s: &'a str) -> Self {
Str(s)
}
fn to_reader(self) -> ReadStr<'a> {
ReadStr(io::Cursor::new(self.0.as_bytes()))
}
}
fn test_debug_matches(new_pattern: impl Fn(&str) -> Result<Pattern, Error>) {
let pat = new_pattern("hello world").unwrap();
assert!(pat.debug_matches(&Str::hello_world()));
let pat = new_pattern("hel+o w[orl]{3}d").unwrap();
assert!(pat.debug_matches(&Str::hello_world()));
let pat = new_pattern("goodbye world").unwrap();
assert_eq!(pat.debug_matches(&Str::hello_world()), false);
}
fn test_display_matches(new_pattern: impl Fn(&str) -> Result<Pattern, Error>) {
let pat = new_pattern("hello world").unwrap();
assert!(pat.display_matches(&Str::hello_world()));
let pat = new_pattern("hel+o w[orl]{3}d").unwrap();
assert!(pat.display_matches(&Str::hello_world()));
let pat = new_pattern("goodbye world").unwrap();
assert_eq!(pat.display_matches(&Str::hello_world()), false);
}
fn test_reader_matches(new_pattern: impl Fn(&str) -> Result<Pattern, Error>) {
let pat = new_pattern("hello world").unwrap();
assert!(pat
.read_matches(Str::hello_world().to_reader())
.expect("no io error should occur"));
let pat = new_pattern("hel+o w[orl]{3}d").unwrap();
assert!(pat
.read_matches(Str::hello_world().to_reader())
.expect("no io error should occur"));
let pat = new_pattern("goodbye world").unwrap();
assert_eq!(
pat.read_matches(Str::hello_world().to_reader())
.expect("no io error should occur"),
false
);
}
fn test_debug_rep_patterns(new_pattern: impl Fn(&str) -> Result<Pattern, Error>) {
let pat = new_pattern("a+b").unwrap();
assert!(pat.debug_matches(&Str::new("ab")));
assert!(pat.debug_matches(&Str::new("aaaab")));
assert!(pat.debug_matches(&Str::new("aaaaaaaaaab")));
assert_eq!(pat.debug_matches(&Str::new("b")), false);
assert_eq!(pat.debug_matches(&Str::new("abb")), false);
assert_eq!(pat.debug_matches(&Str::new("aaaaabb")), false);
}
mod anchored {
use super::*;
#[test]
fn debug_matches() {
test_debug_matches(Pattern::new_anchored)
}
#[test]
fn display_matches() {
test_display_matches(Pattern::new_anchored)
}
#[test]
fn reader_matches() {
test_reader_matches(Pattern::new_anchored)
}
#[test]
fn debug_rep_patterns() {
test_debug_rep_patterns(Pattern::new_anchored)
}
// === anchored behavior =============================================
// Tests that anchored patterns match each input type only beginning at
// the first character.
fn test_is_anchored(f: impl Fn(&Pattern, Str) -> bool) {
let pat = Pattern::new_anchored("a+b").unwrap();
assert!(f(&pat, Str::new("ab")));
assert!(f(&pat, Str::new("aaaab")));
assert!(f(&pat, Str::new("aaaaaaaaaab")));
assert!(!f(&pat, Str::new("bab")));
assert!(!f(&pat, Str::new("ffab")));
assert!(!f(&pat, Str::new("qqqqqqqaaaaab")));
}
#[test]
fn debug_is_anchored() {
test_is_anchored(|pat, input| pat.debug_matches(&input))
}
#[test]
fn display_is_anchored() {
test_is_anchored(|pat, input| pat.display_matches(&input));
}
#[test]
fn reader_is_anchored() {
test_is_anchored(|pat, input| {
pat.read_matches(input.to_reader())
.expect("no io error occurs")
});
}
// === explicitly unanchored =========================================
// Tests that if an "anchored" pattern begins with `.*?`, it matches as
// though it was unanchored.
fn test_explicitly_unanchored(f: impl Fn(&Pattern, Str) -> bool) {
let pat = Pattern::new_anchored(".*?a+b").unwrap();
assert!(f(&pat, Str::new("ab")));
assert!(f(&pat, Str::new("aaaab")));
assert!(f(&pat, Str::new("aaaaaaaaaab")));
assert!(f(&pat, Str::new("bab")));
assert!(f(&pat, Str::new("ffab")));
assert!(f(&pat, Str::new("qqqqqqqaaaaab")));
}
#[test]
fn debug_explicitly_unanchored() {
test_explicitly_unanchored(|pat, input| pat.debug_matches(&input))
}
#[test]
fn display_explicitly_unanchored() {
test_explicitly_unanchored(|pat, input| pat.display_matches(&input));
}
#[test]
fn reader_explicitly_unanchored() {
test_explicitly_unanchored(|pat, input| {
pat.read_matches(input.to_reader())
.expect("no io error occurs")
});
}
}
mod unanchored {
use super::*;
#[test]
fn debug_matches() {
test_debug_matches(Pattern::new)
}
#[test]
fn display_matches() {
test_display_matches(Pattern::new)
}
#[test]
fn reader_matches() {
test_reader_matches(Pattern::new)
}
#[test]
fn debug_rep_patterns() {
test_debug_rep_patterns(Pattern::new)
}
// === anchored behavior =============================================
// Tests that unanchored patterns match anywhere in the input stream.
fn test_is_unanchored(f: impl Fn(&Pattern, Str) -> bool) {
let pat = Pattern::new("a+b").unwrap();
assert!(f(&pat, Str::new("ab")));
assert!(f(&pat, Str::new("aaaab")));
assert!(f(&pat, Str::new("aaaaaaaaaab")));
assert!(f(&pat, Str::new("bab")));
assert!(f(&pat, Str::new("ffab")));
assert!(f(&pat, Str::new("qqqfqqqqaaaaab")));
}
#[test]
fn debug_is_unanchored() {
test_is_unanchored(|pat, input| pat.debug_matches(&input))
}
#[test]
fn display_is_unanchored() {
test_is_unanchored(|pat, input| pat.display_matches(&input));
}
#[test]
fn reader_is_unanchored() {
test_is_unanchored(|pat, input| {
pat.read_matches(input.to_reader())
.expect("no io error occurs")
});
}
}
}