feat(update_expected): add --implementation-status=… filter defaulting to backlog

Author: ErichDonGubler

moz-webgpu-cts/src/main.rs

@@ -38,6 +38,7 @@ use format::lazy_format;
 use indexmap::{IndexMap, IndexSet};
 use itertools::Itertools;
 use joinery::JoinableIterator;
+use metadata::ImplementationStatus;
 use miette::{miette, Diagnostic, IntoDiagnostic, NamedSource, Report, SourceSpan, WrapErr};
 use path_dsl::path;
 use rayon::prelude::{IntoParallelIterator, ParallelIterator};
@@ -97,6 +98,9 @@ enum Subcommand {
         /// The heuristic for resolving differences between current metadata and processed reports.
         #[clap(long, default_value = "reset-contradictory")]
         preset: ReportProcessingPreset,
+        /// The `implementation-status` that changes should be applied to.
+        #[clap(value_enum, long, default_value_t = ImplementationStatus::Backlog)]
+        implementation_status: ImplementationStatus,
     },
     /// Parse test metadata, apply automated fixups, and re-emit it in normalized form.
     #[clap(name = "fixup", alias = "fmt")]
@@ -167,6 +171,7 @@ fn run(cli: Cli) -> ExitCode {
             report_globs,
             report_paths,
             preset,
+            implementation_status,
         } => {
             let report_globs = {
                 let mut found_glob_parse_err = false;
@@ -553,13 +558,28 @@ fn run(cli: Cli) -> ExitCode {
             let recombined_tests_iter = entries_by_cts_path
                 .chain(other_entries_by_test)
                 .filter_map(|(test_path, test_entry)| {
+                    /// Reconciles `meta_props` with `reported` if they match
+                    /// `implementation_status_filter`.
+                    ///
+                    /// For subtests, `parent_implementation_status` should be specified so the
+                    /// parent test's implementation status can be used for filtering.
                     fn reconcile<Out>(
+                        parent_implementation_status: Option<
+                            &ExpandedPropertyValue<ImplementationStatus>,
+                        >,
                         meta_props: &mut TestProps<Out>,
                         reported: BTreeMap<Platform, BTreeMap<BuildProfile, Expected<Out>>>,
                         preset: ReportProcessingPreset,
+                        implementation_status_filter: ImplementationStatus,
                     ) where
                         Out: Debug + Default + EnumSetType,
                     {
+                        let implementation_status = meta_props
+                            .implementation_status
+                            .or(parent_implementation_status.cloned())
+                            .unwrap_or_default();
+                        let should_apply_changes =
+                            |key| implementation_status[key] == implementation_status_filter;
                         let reconciled = {
                             let reported = |(platform, build_profile)| {
                                 reported
@@ -585,7 +605,11 @@ fn run(cli: Cli) -> ExitCode {
 
                                 ExpandedPropertyValue::from_query(|platform, build_profile| {
                                     let key = (platform, build_profile);
-                                    resolve(meta_expected[key], reported(key))
+                                    if should_apply_changes(key) {
+                                        resolve(meta_expected[key], reported(key))
+                                    } else {
+                                        meta_expected[key]
+                                    }
                                 })
                             } else {
                                 ExpandedPropertyValue::from_query(|platform, build_profile| {
@@ -659,7 +683,13 @@ fn run(cli: Cli) -> ExitCode {
                         }
                     }
 
-                    reconcile(&mut properties, test_reported, preset);
+                    reconcile(
+                        None,
+                        &mut properties,
+                        test_reported,
+                        preset,
+                        implementation_status,
+                    );
 
                     let mut subtests = BTreeMap::new();
                     for (subtest_name, subtest) in subtest_entries {
@@ -675,7 +705,13 @@ fn run(cli: Cli) -> ExitCode {
                         } = subtest;
 
                         let mut subtest_properties = subtest_properties.unwrap_or_default();
-                        reconcile(&mut subtest_properties, subtest_reported, preset);
+                        reconcile(
+                            properties.implementation_status.as_ref(),
+                            &mut subtest_properties,
+                            subtest_reported,
+                            preset,
+                            implementation_status,
+                        );
                         for (_, expected) in
                             subtest_properties.expected.as_mut().unwrap().iter_mut()
                         {

moz-webgpu-cts/src/metadata.rs

@@ -4,6 +4,7 @@ use std::{
     hash::Hash,
 };
 
+use clap::ValueEnum;
 use enum_map::Enum;
 use enumset::EnumSetType;
 use format::lazy_format;
@@ -562,7 +563,7 @@ fn format_file_properties(props: &FileProps) -> impl Display + '_ {
     })
 }
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize)]
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, ValueEnum)]
 pub enum ImplementationStatus {
     /// Indicates that functionality governing test(s) is implemented or currently being
     /// implemented, and generally expected to conform to tests.