Run every generated case without the long seed scan

`Case::SizeResize` was in `ALL` and in none of the `case!` invocations, so
a size change followed by a resize -- the order the enum's own comment
argues is not the same test as the other one -- was only ever checked by
the ignored long run. The tests and the list of which cases have one come
from one macro invocation now, and a case missing from it fails a test
rather than going quiet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tests/generated.rs

@@ -47,57 +47,50 @@ fn check_plan(grown: &Plan, seed: u64, depth: usize, case: Case) {
     }
 }
 
-macro_rules! case {
+/// A test per case, and the list of which cases have one, from the same
-    ($name:ident, $case:expr) => {
+/// place. A case the ordinary suite leaves out runs only in the long scan,
-        #[test]
+/// which nobody runs by hand.
-        fn $name() {
+macro_rules! cases {
-            for seed in SEEDS {
+    ($($name:ident = $case:expr,)*) => {
-                check(seed, depth(), $case);
+        $(
+            #[test]
+            fn $name() {
+                for seed in SEEDS {
+                    check(seed, depth(), $case);
+                }
             }
-        }
+        )*
+
+        const NAMED: [Case; [$($case,)*].len()] = [$($case,)*];
     };
 }
 
-case!(
+cases! {
-    many_widgets_redrawing_at_once_leaves_every_box_where_it_was,
+    many_widgets_redrawing_at_once_leaves_every_box_where_it_was = Case::RepaintSome,
-    Case::RepaintSome
+    everything_redrawing_at_once_leaves_every_box_where_it_was = Case::Repaint,
-);
+    a_resize_lands_where_starting_at_that_size_would = Case::Resize,
-case!(
+    a_resize_and_a_repaint_land_where_starting_that_way_would = Case::ResizeRepaint,
-    everything_redrawing_at_once_leaves_every_box_where_it_was,
+    a_size_change_after_a_resize_lands_the_same_way = Case::ResizeSize,
-    Case::Repaint
+    a_resize_after_a_size_change_lands_the_same_way = Case::SizeResize,
-);
+    a_size_change_lands_where_growing_it_that_way_would = Case::Size,
-case!(
+    every_size_changing_at_once_lands_where_growing_it_that_way_would = Case::EverySize,
-    a_resize_lands_where_starting_at_that_size_would,
+    an_alignment_change_lands_where_growing_it_that_way_would = Case::Align,
-    Case::Resize
+    giving_and_taking_a_movable_region_rebuilds_what_resolves_it = Case::RegionNode,
-);
+    reordering_a_span_lands_where_growing_it_that_way_would = Case::Reorder,
-case!(
+}
-    a_resize_and_a_repaint_land_where_starting_that_way_would,
+
-    Case::ResizeRepaint
+/// The shuffles are one test between them, so they are the only cases `ALL`
-);
+/// may hold without a test of their own.
-case!(
+#[test]
-    a_size_change_after_a_resize_lands_the_same_way,
+fn every_case_runs_without_the_long_scan() {
-    Case::ResizeSize
+    for case in ALL {
-);
+        assert!(
-case!(
+            NAMED.contains(&case) || matches!(case, Case::Shuffle(_)),
-    a_size_change_lands_where_growing_it_that_way_would,
+            "{} runs only in the long seed scan; give it a case here",
-    Case::Size
+            case.name()
-);
+        );
-case!(
+    }
-    every_size_changing_at_once_lands_where_growing_it_that_way_would,
+}
-    Case::EverySize
-);
-case!(
-    an_alignment_change_lands_where_growing_it_that_way_would,
-    Case::Align
-);
-case!(
-    giving_and_taking_a_movable_region_rebuilds_what_resolves_it,
-    Case::RegionNode
-);
-case!(
-    reordering_a_span_lands_where_growing_it_that_way_would,
-    Case::Reorder
-);
 
 #[test]
 fn adding_and_removing_span_children_lands_where_growing_it_that_way_would() {