Add servo as browser option

Author: sagudev

moz-webgpu-cts/src/main.rs

@@ -35,6 +35,7 @@ use joinery::JoinableIterator;
 use miette::{miette, Diagnostic, IntoDiagnostic, NamedSource, Report, SourceSpan, WrapErr};
 use path_dsl::path;
 use rayon::prelude::{IntoParallelIterator, ParallelIterator};
+use shared::Browser;
 use strum::IntoEnumIterator;
 use wax::Glob;
 use whippit::{
@@ -45,8 +46,10 @@ use whippit::{
 #[derive(Debug, Parser)]
 #[command(about, version)]
 struct Cli {
-    #[clap(long)]
-    gecko_checkout: Option<PathBuf>,
+    #[clap(long, alias = "gecko-checkout")]
+    checkout: Option<PathBuf>,
+    #[clap(value_enum, long, default_value_t = Default::default())]
+    browser: Browser,
     #[clap(subcommand)]
     subcommand: Subcommand,
 }
@@ -123,35 +126,36 @@ fn main() -> ExitCode {
 
 fn run(cli: Cli) -> ExitCode {
     let Cli {
-        gecko_checkout,
+        browser,
+        checkout,
         subcommand,
     } = cli;
 
-    let gecko_checkout = match gecko_checkout
-        .map(Ok)
-        .unwrap_or_else(search_for_moz_central_ckt)
-    {
+    let checkout = match checkout.map(Ok).unwrap_or_else(search_for_moz_central_ckt) {
         Ok(ckt_path) => ckt_path,
         Err(AlreadyReportedToCommandline) => return ExitCode::FAILURE,
     };
 
     let read_metadata = || -> Result<_, AlreadyReportedToCommandline> {
-        let webgpu_cts_meta_parent_dir =
-            { path!(&gecko_checkout | "testing" | "web-platform" | "mozilla" | "meta" | "webgpu") };
+        let webgpu_cts_meta_parent_dir = match browser {
+            Browser::Firefox => {
+                path!(&checkout | "testing" | "web-platform" | "mozilla" | "meta" | "webgpu")
+            }
+            Browser::Servo => path!(&checkout | "tests" | "wpt" | "webgpu" | "meta" | "webgpu"),
+        };
 
         let mut found_err = false;
-        let collected =
-            read_gecko_files_at(&gecko_checkout, &webgpu_cts_meta_parent_dir, "**/*.ini")?
-                .filter_map(|res| match res {
-                    Ok((p, _contents)) if p.ends_with("__dir__.ini") => None,
-                    Ok(ok) => Some(ok),
-                    Err(AlreadyReportedToCommandline) => {
-                        found_err = true;
-                        None
-                    }
-                })
-                .map(|(p, fc)| (Arc::new(p), Arc::new(fc)))
-                .collect::<IndexMap<_, _>>();
+        let collected = read_files_at(&checkout, &webgpu_cts_meta_parent_dir, "**/*.ini")?
+            .filter_map(|res| match res {
+                Ok((p, _contents)) if p.ends_with("__dir__.ini") => None,
+                Ok(ok) => Some(ok),
+                Err(AlreadyReportedToCommandline) => {
+                    found_err = true;
+                    None
+                }
+            })
+            .map(|(p, fc)| (Arc::new(p), Arc::new(fc)))
+            .collect::<IndexMap<_, _>>();
         if found_err {
             Err(AlreadyReportedToCommandline)
         } else {
@@ -337,7 +341,7 @@ fn run(cli: Cli) -> ExitCode {
             for (path, file) in meta_files_by_path {
                 let File { properties, tests } = file;
 
-                let file_rel_path = path.strip_prefix(&gecko_checkout).unwrap();
+                let file_rel_path = path.strip_prefix(&checkout).unwrap();
 
                 file_props_by_file.insert(
                     Utf8PathBuf::from(file_rel_path.to_str().unwrap()),
@@ -350,7 +354,7 @@ fn run(cli: Cli) -> ExitCode {
                         subtests,
                     } = test;
 
-                    let test_path = TestPath::from_fx_metadata_test(file_rel_path, &name).unwrap();
+                    let test_path = TestPath::from_metadata_test(file_rel_path, &name).unwrap();
 
                     let freak_out_do_nothing = |what: &dyn Display| {
                         log::error!("hoo boy, not sure what to do yet: {what}")
@@ -461,7 +465,7 @@ fn run(cli: Cli) -> ExitCode {
                 for entry in entries {
                     let TestExecutionEntry { test_name, result } = entry;
 
-                    let test_path = TestPath::from_execution_report(&test_name).unwrap();
+                    let test_path = TestPath::from_execution_report(&test_name, browser).unwrap();
                     let TestEntry {
                         entry: test_entry,
                         subtests: subtest_entries,
@@ -707,8 +711,8 @@ fn run(cli: Cli) -> ExitCode {
             let mut files = BTreeMap::<PathBuf, File>::new();
             for (test_path, (properties, subtests)) in recombined_tests_iter {
                 let name = test_path.test_name().to_string();
-                let rel_path = Utf8PathBuf::from(test_path.rel_metadata_path_fx().to_string());
-                let path = gecko_checkout.join(&rel_path);
+                let rel_path = Utf8PathBuf::from(test_path.rel_metadata_path().to_string());
+                let path = checkout.join(&rel_path);
                 let file = files.entry(path).or_insert_with(|| File {
                     properties: file_props_by_file
                         .get(&rel_path)
@@ -829,11 +833,11 @@ fn run(cli: Cli) -> ExitCode {
                                 properties: _,
                                 tests,
                             }) => Some(tests.into_iter().map({
-                                let gecko_checkout = &gecko_checkout;
+                                let checkout = &checkout;
                                 move |(name, inner)| {
                                     let SectionHeader(name) = &name;
-                                    let test_path = TestPath::from_fx_metadata_test(
-                                        path.strip_prefix(gecko_checkout).unwrap(),
+                                    let test_path = TestPath::from_metadata_test(
+                                        path.strip_prefix(checkout).unwrap(),
                                         name,
                                     )
                                     .unwrap();
@@ -1459,20 +1463,20 @@ fn run(cli: Cli) -> ExitCode {
 }
 
 /// Returns a "naturally" sorted list of files found by searching for `glob_pattern` in `base`.
-/// `gecko_checkout` is stripped as a prefix from the absolute paths recorded into `log` entries
+/// `checkout` is stripped as a prefix from the absolute paths recorded into `log` entries
 /// emitted by this function.
 ///
 /// # Returns
 ///
-/// An iterator over [`Result`]s containing either a Gecko file's path and contents as a UTF-8
+/// An iterator over [`Result`]s containing either a checkout file's path and contents as a UTF-8
 /// string, or the sentinel of an error encountered for the same file that is already reported to
 /// the command line.
 ///
 /// # Panics
 ///
-/// This function will panick if `gecko_checkout` cannot be stripped as a prefix of `base`.
-fn read_gecko_files_at(
-    gecko_checkout: &Path,
+/// This function will panick if `checkout` cannot be stripped as a prefix of `base`.
+fn read_files_at(
+    checkout: &Path,
     base: &Path,
     glob_pattern: &str,
 ) -> Result<
@@ -1489,7 +1493,7 @@ fn read_gecko_files_at(
             Err(e) => {
                 let path_disp = e
                     .path()
-                    .map(|p| format!(" in {}", p.strip_prefix(gecko_checkout).unwrap().display()));
+                    .map(|p| format!(" in {}", p.strip_prefix(checkout).unwrap().display()));
                 let path_disp: &dyn Display = match path_disp.as_ref() {
                     Some(disp) => disp,
                     None => &"",
@@ -1511,7 +1515,7 @@ fn read_gecko_files_at(
         "working with these files: {:#?}",
         paths
             .iter()
-            .map(|f| f.strip_prefix(gecko_checkout).unwrap())
+            .map(|f| f.strip_prefix(checkout).unwrap())
             .collect::<std::collections::BTreeSet<_>>()
     );