Merge pull request #278 from oli-obk/miri

Some changes needed for miri

Author: oli-obk

CHANGELOG.md

@@ -13,6 +13,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+* `only`/`ignore` filters now only accept integers, alphabetic characters, `-` and `_`
+* `only`/ `ignore` filters allow comments by ignoring everything from an `#` onwards
+
 ### Removed
 
 ## [0.26.4] - 2024-09-09

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "ui_test"
-version = "0.26.4"
+version = "0.26.5"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "A test framework for testing rustc diagnostics output"

Cargo.toml

@@ -7,7 +7,7 @@ use std::{
 };
 
 use color_eyre::eyre::Result;
-use crossbeam_channel::Sender;
+use crossbeam_channel::{bounded, Sender};
 
 use crate::{
     status_emitter::{RevisionStyle, TestStatus},
@@ -47,6 +47,11 @@ impl BuildManager {
         }
     }
 
+    /// Create a new `BuildManager` that cannot create new sub-jobs.
+    pub fn one_off(config: Config) -> Self {
+        Self::new(config, bounded(0).0)
+    }
+
     /// Lazily add more jobs after a test has finished. These are added to the queue
     /// as normally, but nested below the test.
     pub fn add_new_job(&self, job: impl Send + 'static + FnOnce() -> TestRun) {

src/build_manager.rs

@@ -395,8 +395,8 @@ impl Config {
         let target = self.target.as_ref().unwrap();
         match condition {
             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::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/config.rs

@@ -225,15 +225,51 @@ impl<T> std::ops::DerefMut for CommentParser<T> {
 #[derive(Debug, Clone)]
 pub enum Condition {
     /// One of the given strings must appear in the host triple.
-    Host(Vec<String>),
+    Host(Vec<TargetSubStr>),
     /// One of the given string must appear in the target triple.
-    Target(Vec<String>),
+    Target(Vec<TargetSubStr>),
     /// Tests that the bitwidth is one of the given ones.
     Bitwidth(Vec<u8>),
     /// Tests that the target is the host.
     OnHost,
 }
 
+#[derive(Debug, Clone)]
+/// A sub string of a target (or a whole target).
+/// Effectively a `String` that only allows lowercase chars, integers and dashes
+pub struct TargetSubStr(String);
+
+impl PartialEq<&str> for TargetSubStr {
+    fn eq(&self, other: &&str) -> bool {
+        self.0 == *other
+    }
+}
+
+impl std::ops::Deref for TargetSubStr {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl TryFrom<String> for TargetSubStr {
+    type Error = String;
+
+    fn try_from(value: String) -> std::result::Result<Self, Self::Error> {
+        if value
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
+        {
+            Ok(Self(value))
+        } else {
+            Err(format!(
+                "target strings can only contain integers, basic alphabet characters or dashes"
+            ))
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 /// An error pattern parsed from a `//~` comment.
 pub enum Pattern {
@@ -270,8 +306,8 @@ impl Condition {
                 })).collect::<Result<Vec<_>, _>>()?;
                 Ok(Condition::Bitwidth(bits))
             }
-            "target" => Ok(Condition::Target(args.map(|arg|arg.to_owned()).collect())),
-            "host" => Ok(Condition::Host(args.map(|arg|arg.to_owned()).collect())),
+            "target" => Ok(Condition::Target(args.take_while(|&arg| arg != "#").map(|arg|TargetSubStr::try_from(arg.to_owned())).collect::<Result<_, _>>()?)),
+            "host" => Ok(Condition::Host(args.take_while(|&arg| arg != "#").map(|arg|TargetSubStr::try_from(arg.to_owned())).collect::<Result<_, _>>()?)),
             _ => Err(format!("`{c}` is not a valid condition, expected `on-host`, /[0-9]+bit/, /host-.*/, or /target-.*/")),
         }
     }
@@ -576,7 +612,7 @@ impl CommentParser<Comments> {
             }
             Some(i) => {
                 let (command, args) = command.split_at(i);
-                // Commands are separated from their arguments by ':' or ' '
+                // Commands are separated from their arguments by ':'
                 let next = args
                     .chars()
                     .next()

src/parser.rs

@@ -255,14 +255,17 @@ 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.len(), 1);
+            assert_eq!(t[0], "x86_64-unknown-linux")
+        }
         _ => unreachable!(),
     }
 }
 
 #[test]
 fn parse_two_only_filters() {
-    let s = r"//@only-target: hello world";
+    let s = r"//@only-target: hello world # some comment";
     let comments = Comments::parse(
         Spanned::new(
             s.as_bytes(),
@@ -279,7 +282,27 @@ fn parse_two_only_filters() {
     let revisioned = &comments.revisioned[&vec![]];
     assert_eq!(revisioned.only.len(), 1);
     match &revisioned.only[0] {
-        Condition::Target(t) => assert_eq!(t, &["hello", "world"]),
+        Condition::Target(t) => {
+            assert_eq!(t.len(), 2);
+            assert_eq!(t[0], "hello");
+            assert_eq!(t[1], "world")
+        }
         _ => unreachable!(),
     }
 }
+
+#[test]
+fn parse_invalid_filter() {
+    let s = r"//@only-target: hello world: somecomment";
+    Comments::parse(
+        Spanned::new(
+            s.as_bytes(),
+            Span {
+                file: PathBuf::new(),
+                bytes: 0..s.len(),
+            },
+        ),
+        &Config::dummy(),
+    )
+    .unwrap_err();
+}