Merge pull request #153 from erichdongubler-mozilla/update_backlog-verb_criteria-model

Author: ErichDonGubler

moz-webgpu-cts/src/main.rs

@@ -127,12 +127,14 @@ enum Subcommand {
         #[clap(value_enum, long, default_value_t = Default::default())]
         on_zero_item: OnZeroItem,
     },
-    /// Identify and promote tests that are ready to come out of the `backlog` implementation
-    /// status.
+    /// Set `implementation-status` properties to `backlog` or `implementing` based on a
+    /// given `criteria`, allowing changes only in the permitted `direction`.
     UpdateBacklog {
-        /// The mode to use for updating tests.
+        /// Direction(s) permitted for `implementation-status` changes.
+        direction: UpdateBacklogDirection,
+        /// The criteria to use to determine whether something is ready to come out of `backlog`.
         #[clap(subcommand)]
-        preset: UpdateBacklogSubcommand,
+        criteria: UpdateBacklogCriteria,
     },
     /// Dump all metadata as JSON. Do so at your own risk; no guarantees are made about the
     /// schema of this JSON, for now.
@@ -289,10 +291,34 @@ enum OnZeroItem {
     Hide,
 }
 
+#[derive(Clone, Copy, Debug, ValueEnum)]
+enum UpdateBacklogDirection {
+    /// Allows promotions from `backlog` to `implementing`.
+    Promote,
+    Demote,
+    Sync,
+}
+
+impl UpdateBacklogDirection {
+    pub fn can_promote(self) -> bool {
+        match self {
+            Self::Promote | Self::Sync => true,
+            Self::Demote => false,
+        }
+    }
+
+    pub fn can_demote(self) -> bool {
+        match self {
+            Self::Demote | Self::Sync => true,
+            Self::Promote => false,
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, Parser)]
-enum UpdateBacklogSubcommand {
-    /// Remove tests that expect only `PASS` outcomes on all platforms from `backlog`.
-    PromotePermaPassing {
+enum UpdateBacklogCriteria {
+    /// Determine status based on `PASS` outcomes on all platforms from `backlog`.
+    PermaPassing {
         #[clap(long)]
         only_across_all_platforms: bool,
     },
@@ -985,7 +1011,10 @@ fn run(cli: Cli) -> ExitCode {
             println!("Full analysis: {analysis:#?}");
             ExitCode::SUCCESS
         }
-        Subcommand::UpdateBacklog { preset } => {
+        Subcommand::UpdateBacklog {
+            direction,
+            criteria,
+        } => {
             let mut files = {
                 let mut found_parse_err = false;
                 let extracted = read_and_parse_all_metadata(browser, &checkout)
@@ -1063,18 +1092,40 @@ fn run(cli: Cli) -> ExitCode {
                     // subtests afterwards.
                     let value_across_all_platforms =
                         || cases.into_iter().map(|(_, case)| case).all_equal_value();
-                    match preset {
-                        UpdateBacklogSubcommand::PromotePermaPassing {
+                    fn apply_criteria(
+                        direction: UpdateBacklogDirection,
+                        case: Case,
+                    ) -> Option<ImplementationStatus> {
+                        match case {
+                            Case::PermaPass if direction.can_promote() => {
+                                Some(ImplementationStatus::Implementing)
+                            }
+                            Case::Other if direction.can_demote() => {
+                                Some(ImplementationStatus::Backlog)
+                            }
+                            _ => None,
+                        }
+                    }
+                    match criteria {
+                        UpdateBacklogCriteria::PermaPassing {
                             only_across_all_platforms,
                         } => {
-                            if matches!(value_across_all_platforms(), Ok(Case::PermaPass)) {
-                                properties.implementation_status = None;
-                            } else if !only_across_all_platforms {
-                                properties.implementation_status =
-                                    Some(cases.map(|case| match case {
-                                        Case::PermaPass => ImplementationStatus::Implementing,
-                                        Case::Other => ImplementationStatus::Backlog,
-                                    }));
+                            if only_across_all_platforms {
+                                properties.implementation_status = apply_criteria(
+                                    direction,
+                                    value_across_all_platforms().unwrap_or(Case::Other),
+                                )
+                                .map(ExpandedPropertyValue::unconditional)
+                                .or(properties.implementation_status);
+                            } else {
+                                let old_impl_status =
+                                    properties.implementation_status.unwrap_or_default();
+                                properties.implementation_status.replace(cases.map_with(
+                                    |key, case| {
+                                        apply_criteria(direction, case)
+                                            .unwrap_or_else(|| old_impl_status[key])
+                                    },
+                                ));
                             }
                         }
                     }

moz-webgpu-cts/src/wpt/metadata/properties.rs

@@ -276,6 +276,16 @@ impl<T> ExpandedPropertyValue<T> {
         )
     }
 
+    pub(crate) fn map_with<U, F>(self, f: F) -> ExpandedPropertyValue<U>
+    where
+        F: FnMut((Platform, BuildProfile), T) -> U,
+    {
+        let mut f = f;
+        ExpandedPropertyValue(self.into_inner().map(|platform, by_build_profile| {
+            by_build_profile.map(|build_profile, t| f((platform, build_profile), t))
+        }))
+    }
+
     fn into_inner(self) -> ExpandedPropertyValueData<T> {
         let Self(inner) = self;
         inner