Add disjunctive "only" filters

Author: oli-obk

CHANGELOG.md

@@ -18,8 +18,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * default comment symbols for `Config::cargo` changed to `#`
 * Ctrl+C now prints the summary of the tests that were run before Ctrl+C is pressed
-* `//@only-target` and `//@only-host` are now separated from the triple substring by a `:` instead of a `-`
-* `//@only-64bit` is now `//@only-bitwidth: 64`
+* `//@only-target` and `//@only-host` are now separated from the triple substring by a `:` instead of a `-` and accepts multiple (space separated) filters where just one of them needs to match
+* `//@only-64bit` is now `//@only-bitwidth: 64 16` to filter for 64 and 16 bit but not include 32 bit.
 
 ### Removed
 

README.md

@@ -45,9 +45,9 @@ Any other comments will be ignored, and all `//@` comments must be formatted pre
 their command specifies, or the test will fail without even being run.
 
 * `//@ignore-C` avoids running the test when condition `C` is met.
-    * `C` can be `target: XXX`, which checks whether the target triple contains `XXX`.
-    * `C` can be `host: XXX`, which checks whether the host triple contains `XXX`.
-    * `C` can also be `bitwidth:` followed by an integer size like `64`, `32` or `16`.
+    * `C` can be `target: XXX YYY`, which checks whether the target triple contains `XXX` or `YYY`.
+    * `C` can be `host: XXX YYY`, which checks whether the host triple contains `XXX` or `YYY`.
+    * `C` can also be `bitwidth:` followed by one or more space separated integer size like `64`, `32` or `16`.
     * `C` can also be `on-host`, which will only run the test during cross compilation testing.
 * `//@only-C` **only** runs the test when condition `C` is met. The conditions are the same as with `ignore`.
 * `//@needs-asm-support` **only** runs the test when the target supports `asm!`.

src/config.rs

@@ -386,9 +386,9 @@ impl Config {
     pub(crate) fn test_condition(&self, condition: &Condition) -> bool {
         let target = self.target.as_ref().unwrap();
         match condition {
-            Condition::Bitwidth(bits) => self.get_pointer_width() == *bits,
-            Condition::Target(t) => target.contains(t),
-            Condition::Host(t) => self.host.as_ref().unwrap().contains(t),
+            Condition::Bitwidth(bits) => bits.iter().any(|bits| self.get_pointer_width() == *bits),
+            Condition::Target(t) => t.iter().any(|t| target.contains(t)),
+            Condition::Host(t) => t.iter().any(|t| self.host.as_ref().unwrap().contains(t)),
             Condition::OnHost => self.host_matches_target(),
         }
     }

src/parser.rs

@@ -226,12 +226,12 @@ impl<T> std::ops::DerefMut for CommentParser<T> {
 /// The conditions used for "ignore" and "only" filters.
 #[derive(Debug, Clone)]
 pub enum Condition {
-    /// The given string must appear in the host triple.
-    Host(String),
-    /// The given string must appear in the target triple.
-    Target(String),
-    /// Tests that the bitwidth is the given one.
-    Bitwidth(u8),
+    /// One of the given strings must appear in the host triple.
+    Host(Vec<String>),
+    /// One of the given string must appear in the target triple.
+    Target(Vec<String>),
+    /// Tests that the bitwidth is one of the given ones.
+    Bitwidth(Vec<u8>),
     /// Tests that the target is the host.
     OnHost,
 }
@@ -263,16 +263,17 @@ pub(crate) struct ErrorMatch {
 
 impl Condition {
     fn parse(c: &str, args: &str) -> std::result::Result<Self, String> {
+        let args = args.split_whitespace();
         match c {
             "on-host" => Ok(Condition::OnHost),
             "bitwidth" => {
-                let bits: u8 = args.parse().map_err(|_err| {
+                let bits = args.map(|arg| arg.parse::<u8>().map_err(|_err| {
                     format!("invalid ignore/only filter ending in 'bit': {c:?} is not a valid bitwdith")
-                })?;
+                })).collect::<Result<Vec<_>, _>>()?;
                 Ok(Condition::Bitwidth(bits))
             }
-            "target" => Ok(Condition::Target(args.to_owned())),
-            "host" => Ok(Condition::Host(args.to_owned())),
+            "target" => Ok(Condition::Target(args.map(|arg|arg.to_owned()).collect())),
+            "host" => Ok(Condition::Host(args.map(|arg|arg.to_owned()).collect())),
             _ => Err(format!("`{c}` is not a valid condition, expected `on-host`, /[0-9]+bit/, /host-.*/, or /target-.*/")),
         }
     }

src/parser/tests.rs

@@ -255,7 +255,31 @@ fn parse_x86_64() {
     let revisioned = &comments.revisioned[&vec![]];
     assert_eq!(revisioned.only.len(), 1);
     match &revisioned.only[0] {
-        Condition::Target(t) => assert_eq!(t, "x86_64-unknown-linux"),
+        Condition::Target(t) => assert_eq!(t, &["x86_64-unknown-linux"]),
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn parse_two_only_filters() {
+    let s = r"//@only-target: hello world";
+    let comments = Comments::parse(
+        Spanned::new(
+            s.as_bytes(),
+            Span {
+                file: PathBuf::new(),
+                bytes: 0..s.len(),
+            },
+        ),
+        &Config::rustc(""),
+    )
+    .unwrap();
+    println!("parsed comments: {:#?}", comments);
+    assert_eq!(comments.revisioned.len(), 1);
+    let revisioned = &comments.revisioned[&vec![]];
+    assert_eq!(revisioned.only.len(), 1);
+    match &revisioned.only[0] {
+        Condition::Target(t) => assert_eq!(t, &["hello", "world"]),
         _ => unreachable!(),
     }
 }