Upgrade rust/crates/regex to 1.4.5
Test: make
Change-Id: I1d9343bd9712ddd57023af2c5d248993a2c31088
diff --git a/tests/consistent.rs b/tests/consistent.rs
index 0f9ea53..722f2a5 100644
--- a/tests/consistent.rs
+++ b/tests/consistent.rs
@@ -157,10 +157,7 @@
}
impl quickcheck::Testable for RegexEqualityTest {
- fn result<G: quickcheck::Gen>(
- &self,
- gen: &mut G,
- ) -> TestResult {
+ fn result(&self, gen: &mut quickcheck::Gen) -> TestResult {
let input = $mk_input(gen);
let input = &input;
diff --git a/tests/crazy.rs b/tests/crazy.rs
index 56f6cad..293ac1a 100644
--- a/tests/crazy.rs
+++ b/tests/crazy.rs
@@ -137,9 +137,10 @@
#[test]
fn dfa_handles_pathological_case() {
fn ones_and_zeroes(count: usize) -> String {
- use rand::{thread_rng, Rng};
+ use rand::rngs::SmallRng;
+ use rand::{Rng, SeedableRng};
- let mut rng = thread_rng();
+ let mut rng = SmallRng::from_entropy();
let mut s = String::new();
for _ in 0..count {
if rng.gen() {
diff --git a/tests/macros_bytes.rs b/tests/macros_bytes.rs
index 03c370d..3d6c8c3 100644
--- a/tests/macros_bytes.rs
+++ b/tests/macros_bytes.rs
@@ -4,7 +4,6 @@
macro_rules! match_text { ($text:expr) => { $text.as_bytes() } }
macro_rules! use_ { ($($path: tt)*) => { use regex::bytes::$($path)*; } }
macro_rules! empty_vec { () => { <Vec<&[u8]>>::new() } }
-
macro_rules! bytes { ($text:expr) => { $text } }
macro_rules! no_expand {
diff --git a/tests/macros_str.rs b/tests/macros_str.rs
index 9b996b3..7b7eb11 100644
--- a/tests/macros_str.rs
+++ b/tests/macros_str.rs
@@ -4,6 +4,7 @@
macro_rules! match_text { ($text:expr) => { $text.as_str() } }
macro_rules! use_ { ($($path: tt)*) => { use regex::$($path)*; } }
macro_rules! empty_vec { () => { <Vec<&str>>::new() } }
+macro_rules! bytes { ($text:expr) => { std::str::from_utf8($text.as_ref()).unwrap() } }
macro_rules! no_expand {
($text:expr) => {{
diff --git a/tests/replace.rs b/tests/replace.rs
index c156a39..700aff2 100644
--- a/tests/replace.rs
+++ b/tests/replace.rs
@@ -130,3 +130,101 @@
t!("${1}a $1a"),
"ba "
);
+
+replace!(
+ impl_string,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ t!("Z".to_string()),
+ "age: Z6"
+);
+replace!(
+ impl_string_ref,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ t!(&"Z".to_string()),
+ "age: Z6"
+);
+replace!(
+ impl_cow_str_borrowed,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ t!(std::borrow::Cow::<'_, str>::Borrowed("Z")),
+ "age: Z6"
+);
+replace!(
+ impl_cow_str_borrowed_ref,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ t!(&std::borrow::Cow::<'_, str>::Borrowed("Z")),
+ "age: Z6"
+);
+replace!(
+ impl_cow_str_owned,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ t!(std::borrow::Cow::<'_, str>::Owned("Z".to_string())),
+ "age: Z6"
+);
+replace!(
+ impl_cow_str_owned_ref,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ t!(&std::borrow::Cow::<'_, str>::Owned("Z".to_string())),
+ "age: Z6"
+);
+
+replace!(
+ impl_vec_u8,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ bytes!(vec![b'Z']),
+ "age: Z6"
+);
+replace!(
+ impl_vec_u8_ref,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ bytes!(&vec![b'Z']),
+ "age: Z6"
+);
+replace!(
+ impl_cow_slice_borrowed,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ bytes!(std::borrow::Cow::<'_, [u8]>::Borrowed(&[b'Z'])),
+ "age: Z6"
+);
+replace!(
+ impl_cow_slice_borrowed_ref,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ bytes!(&std::borrow::Cow::<'_, [u8]>::Borrowed(&[b'Z'])),
+ "age: Z6"
+);
+replace!(
+ impl_cow_slice_owned,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ bytes!(std::borrow::Cow::<'_, [u8]>::Owned(vec![b'Z'])),
+ "age: Z6"
+);
+replace!(
+ impl_cow_slice_owned_ref,
+ replace,
+ r"[0-9]",
+ "age: 26",
+ bytes!(&std::borrow::Cow::<'_, [u8]>::Owned(vec![b'Z'])),
+ "age: Z6"
+);
diff --git a/tests/test_default.rs b/tests/test_default.rs
index 241e580..af634a0 100644
--- a/tests/test_default.rs
+++ b/tests/test_default.rs
@@ -83,26 +83,49 @@
#[test]
fn oibits() {
use regex::bytes;
- use regex::{Regex, RegexBuilder};
- use std::panic::UnwindSafe;
+ use regex::{Regex, RegexBuilder, RegexSet, RegexSetBuilder};
+ use std::panic::{RefUnwindSafe, UnwindSafe};
fn assert_send<T: Send>() {}
fn assert_sync<T: Sync>() {}
fn assert_unwind_safe<T: UnwindSafe>() {}
+ fn assert_ref_unwind_safe<T: RefUnwindSafe>() {}
assert_send::<Regex>();
assert_sync::<Regex>();
assert_unwind_safe::<Regex>();
+ assert_ref_unwind_safe::<Regex>();
assert_send::<RegexBuilder>();
assert_sync::<RegexBuilder>();
assert_unwind_safe::<RegexBuilder>();
+ assert_ref_unwind_safe::<RegexBuilder>();
assert_send::<bytes::Regex>();
assert_sync::<bytes::Regex>();
assert_unwind_safe::<bytes::Regex>();
+ assert_ref_unwind_safe::<bytes::Regex>();
assert_send::<bytes::RegexBuilder>();
assert_sync::<bytes::RegexBuilder>();
assert_unwind_safe::<bytes::RegexBuilder>();
+ assert_ref_unwind_safe::<bytes::RegexBuilder>();
+
+ assert_send::<RegexSet>();
+ assert_sync::<RegexSet>();
+ assert_unwind_safe::<RegexSet>();
+ assert_ref_unwind_safe::<RegexSet>();
+ assert_send::<RegexSetBuilder>();
+ assert_sync::<RegexSetBuilder>();
+ assert_unwind_safe::<RegexSetBuilder>();
+ assert_ref_unwind_safe::<RegexSetBuilder>();
+
+ assert_send::<bytes::RegexSet>();
+ assert_sync::<bytes::RegexSet>();
+ assert_unwind_safe::<bytes::RegexSet>();
+ assert_ref_unwind_safe::<bytes::RegexSet>();
+ assert_send::<bytes::RegexSetBuilder>();
+ assert_sync::<bytes::RegexSetBuilder>();
+ assert_unwind_safe::<bytes::RegexSetBuilder>();
+ assert_ref_unwind_safe::<bytes::RegexSetBuilder>();
}
// See: https://github.com/rust-lang/regex/issues/568
@@ -113,3 +136,18 @@
let _ = panic::catch_unwind(|| Regex::new("a").unwrap());
}
+
+// See: https://github.com/rust-lang/regex/issues/750
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn regex_is_reasonably_small() {
+ use std::mem::size_of;
+
+ use regex::bytes;
+ use regex::{Regex, RegexSet};
+
+ assert_eq!(16, size_of::<Regex>());
+ assert_eq!(16, size_of::<RegexSet>());
+ assert_eq!(16, size_of::<bytes::Regex>());
+ assert_eq!(16, size_of::<bytes::RegexSet>());
+}