diff --git a/dev/rust-regressions.sh b/dev/rust-regressions.sh index 2196538..117c62f 100755 --- a/dev/rust-regressions.sh +++ b/dev/rust-regressions.sh @@ -35,8 +35,9 @@ fi if [ "$c" = 0 ]; then results["UNKNOWN"]+="$url"$'\n' - results["UNKNOWN"]+="$(zgrep ^error "$url" | head -n3 || true)" - results["UNKNOWN"]+=$'\n\n' + results["UNKNOWN"]+="$(zgrep ^error "$url" | head -n3 || true)"$'\n' + results["UNKNOWN"]+="$(zgrep -w FAIL "$url" | sort -u || true)"$'\n' + results["UNKNOWN"]+=$'\n' fi } diff --git a/src/regex-automata/debian/changelog b/src/regex-automata/debian/changelog index 3ad8f91..7e482e1 100644 --- a/src/regex-automata/debian/changelog +++ b/src/regex-automata/debian/changelog @@ -1,3 +1,11 @@ +rust-regex-automata (0.1.8-2) UNRELEASED-FIXME-AUTOGENERATED-DEBCARGO; urgency=medium + + * Team upload. + * Package regex-automata 0.1.8 from crates.io using debcargo 2.4.2 + * Ignore std tests so they don't fail autopkgtest. + + -- Ximin Luo Thu, 16 Jan 2020 23:52:13 +0000 + rust-regex-automata (0.1.8-1) unstable; urgency=medium * Package regex-automata 0.1.8 from crates.io using debcargo 2.4.0 diff --git a/src/regex-automata/debian/copyright.debcargo.hint b/src/regex-automata/debian/copyright.debcargo.hint index bda58fc..87dfaf9 100644 --- a/src/regex-automata/debian/copyright.debcargo.hint +++ b/src/regex-automata/debian/copyright.debcargo.hint @@ -21,8 +21,8 @@ Files: debian/* Copyright: - 2019 Debian Rust Maintainers - 2019 Sylvestre Ledru + 2019-2020 Debian Rust Maintainers + 2019-2020 Sylvestre Ledru License: Unlicense or MIT License: MIT diff --git a/src/regex-automata/debian/patches/ignore-std-tests.patch b/src/regex-automata/debian/patches/ignore-std-tests.patch new file mode 100644 index 0000000..97c7655 --- /dev/null +++ b/src/regex-automata/debian/patches/ignore-std-tests.patch @@ -0,0 +1,220 @@ +--- a/src/dense.rs ++++ b/src/dense.rs +@@ -119,7 +119,7 @@ + /// This type implements the [`DFA`](trait.DFA.html) trait, which means it + /// can be used for searching. For example: + /// +-/// ``` ++#[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::{DFA, DenseDFA}; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -502,7 +502,7 @@ + /// decrease the size of the DFA and to avoid platform specific pitfalls + /// such as differing pointer sizes. + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::{DFA, DenseDFA}; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -2246,6 +2246,7 @@ + String::from_utf8(ascii::escape_default(b).collect::>()).unwrap() + } + ++#[cfg(feature = "std")] + #[cfg(test)] + #[allow(dead_code)] + mod tests { +--- a/tests/tests.rs ++++ b/tests/tests.rs +@@ -10,7 +10,10 @@ + extern crate serde_derive; + extern crate toml; + ++#[cfg(feature = "std")] + mod collection; ++#[cfg(feature = "std")] + mod regression; ++#[cfg(feature = "std")] + mod suite; + mod unescape; +--- a/src/dfa.rs ++++ b/src/dfa.rs +@@ -78,7 +78,7 @@ + /// This example shows how to use this method with a + /// [`DenseDFA`](enum.DenseDFA.html). + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::{DFA, DenseDFA}; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -104,7 +104,7 @@ + /// This example shows how to use this method with a + /// [`DenseDFA`](enum.DenseDFA.html). + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::{DFA, DenseDFA}; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -153,7 +153,7 @@ + /// both `Sam|Samwise` and `Samwise|Sam` match `Samwise` when using + /// leftmost longest semantics. + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::{DFA, DenseDFA}; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -187,7 +187,7 @@ + /// `find` and `rfind` with the same DFA since any particular DFA will only + /// support searching in one direction. + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::{dense, DFA}; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +--- a/src/lib.rs ++++ b/src/lib.rs +@@ -29,7 +29,7 @@ + This example shows how to compile a regex using the default configuration + and then use it to find matches in a byte string: + +-``` ++*/#![cfg_attr(feature = "std", doc = "```")] #![cfg_attr(not(feature = "std"), doc = "```ignore")]/*! + use regex_automata::Regex; + + let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap(); +@@ -48,7 +48,7 @@ + Using sparse DFAs is as easy as using `Regex::new_sparse` instead of + `Regex::new`: + +-``` ++*/#![cfg_attr(feature = "std", doc = "```")] #![cfg_attr(not(feature = "std"), doc = "```ignore")]/*! + use regex_automata::Regex; + + # fn example() -> Result<(), regex_automata::Error> { +@@ -62,7 +62,7 @@ + If you already have dense DFAs for some reason, they can be converted to sparse + DFAs and used to build a new `Regex`. For example: + +-``` ++*/#![cfg_attr(feature = "std", doc = "```")] #![cfg_attr(not(feature = "std"), doc = "```ignore")]/*! + use regex_automata::Regex; + + # fn example() -> Result<(), regex_automata::Error> { +@@ -86,7 +86,7 @@ + deserialization is guaranteed to be cheap because it will always be a constant + time operation. + +-``` ++*/#![cfg_attr(feature = "std", doc = "```")] #![cfg_attr(not(feature = "std"), doc = "```ignore")]/*! + use regex_automata::{DenseDFA, Regex}; + + # fn example() -> Result<(), regex_automata::Error> { +@@ -139,7 +139,7 @@ + + The same process can be achieved with sparse DFAs as well: + +-``` ++*/#![cfg_attr(feature = "std", doc = "```")] #![cfg_attr(not(feature = "std"), doc = "```ignore")]/*! + use regex_automata::{SparseDFA, Regex}; + + # fn example() -> Result<(), regex_automata::Error> { +--- a/src/regex.rs ++++ b/src/regex.rs +@@ -86,7 +86,7 @@ + /// enough to build corresponding sparse DFAs, and then build a regex from + /// them: + /// +-/// ``` ++#[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::Regex; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -179,7 +179,7 @@ + /// + /// # Example + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::Regex; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -201,7 +201,7 @@ + /// + /// # Example + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::Regex; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -235,7 +235,7 @@ + /// + /// # Example + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::Regex; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -313,7 +313,7 @@ + /// + /// # Example + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::Regex; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -342,7 +342,7 @@ + /// would involve serializing `initial_re` somewhere and then deserializing + /// it later to build a regex. + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::Regex; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -358,7 +358,7 @@ + /// This example shows how you might build smaller DFAs, and then use those + /// smaller DFAs to build a new regex. + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::Regex; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -375,7 +375,7 @@ + /// This example shows how to build a `Regex` that uses sparse DFAs instead + /// of dense DFAs: + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::Regex; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +--- a/src/sparse.rs ++++ b/src/sparse.rs +@@ -86,7 +86,7 @@ + /// This type implements the [`DFA`](trait.DFA.html) trait, which means it + /// can be used for searching. For example: + /// +-/// ``` ++#[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::{DFA, SparseDFA}; + /// + /// # fn example() -> Result<(), regex_automata::Error> { +@@ -393,7 +393,7 @@ + /// decrease the size of the DFA and to avoid platform specific pitfalls + /// such as differing pointer sizes. + /// +- /// ``` ++ #[cfg_attr(feature = "std", doc = "```")] #[cfg_attr(not(feature = "std"), doc = "```ignore")] + /// use regex_automata::{DFA, DenseDFA, SparseDFA}; + /// + /// # fn example() -> Result<(), regex_automata::Error> { diff --git a/src/regex-automata/debian/patches/series b/src/regex-automata/debian/patches/series new file mode 100644 index 0000000..e54d5ab --- /dev/null +++ b/src/regex-automata/debian/patches/series @@ -0,0 +1 @@ +ignore-std-tests.patch