Add comprehensive testing infrastructure: visual snapshots, unit, property, and theme tests

Introduces a multi-layered testing strategy for the libcosmic widget toolkit:

- Visual snapshot testing: Renders widgets via tiny-skia software renderer and
  compares pixel output against reference PNGs. Generates diff images on failure.
  Covers containers, dividers, text styles, progress bars, and layouts.

- Widget unit tests: Thorough behavioral tests for segmented button model
  (selection, ordering, data storage, enable/disable, closable, indent),
  calendar model (month navigation, year wrapping, date selection, grid layout),
  spin button (clamping, increment/decrement, float support), and color picker.

- Property-based tests (proptest): Randomized input testing for spin button
  bounds invariants, calendar first-day-of-week correctness, segmented model
  length/clear/toggle invariants, and theme spacing monotonicity.

- Theme consistency tests: Validates all four theme variants (dark, light,
  high-contrast dark/light) have valid spacing, corner radii ordering,
  non-zero-alpha colors, visible text-on-background, and RON round-trip
  serialization.

- Expanded inline tests: 16 new spin_button unit tests covering increment,
  decrement, clamping, float types, and constructor value bounds.

- CI integration: New visual-tests job runs snapshot, theme, property, and
  widget tests with artifact upload on failure for snapshot diffs.

https://claude.ai/code/session_01P3WLXMif9wmNXbWDo5FhRQ

tests/theme_tests.rs

@@ -0,0 +1,291 @@
+// Copyright 2024 System76 <info@system76.com>
+// SPDX-License-Identifier: MPL-2.0
+
+//! Theme and style consistency tests for COSMIC.
+//!
+//! These tests verify that the COSMIC theme system produces consistent,
+//! valid output across different theme variants (light, dark, high-contrast).
+//! They catch issues like missing colors, zero-alpha components, and
+//! inconsistencies between theme variants.
+
+use cosmic::theme;
+use cosmic_theme::Theme as CosmicTheme;
+
+// ---------------------------------------------------------------------------
+// Theme variant consistency tests
+// ---------------------------------------------------------------------------
+
+fn all_themes() -> Vec<(&'static str, &'static CosmicTheme)> {
+    vec![
+        ("dark", &*theme::COSMIC_DARK),
+        ("light", &*theme::COSMIC_LIGHT),
+        ("hc_dark", &*theme::COSMIC_HC_DARK),
+        ("hc_light", &*theme::COSMIC_HC_LIGHT),
+    ]
+}
+
+#[test]
+fn all_themes_have_valid_spacing() {
+    for (name, t) in all_themes() {
+        assert!(t.spacing.space_xxs > 0, "{name}: space_xxs is zero");
+        assert!(t.spacing.space_xs > 0, "{name}: space_xs is zero");
+        assert!(t.spacing.space_s > 0, "{name}: space_s is zero");
+        assert!(t.spacing.space_m > 0, "{name}: space_m is zero");
+        assert!(t.spacing.space_l > 0, "{name}: space_l is zero");
+        assert!(t.spacing.space_xl > 0, "{name}: space_xl is zero");
+        assert!(t.spacing.space_xxl > 0, "{name}: space_xxl is zero");
+    }
+}
+
+#[test]
+fn all_themes_have_valid_corner_radii() {
+    for (name, t) in all_themes() {
+        let radii = &t.corner_radii;
+        // Corner radii should be non-negative
+        for r in &radii.radius_0 {
+            assert!(*r >= 0.0, "{name}: negative radius_0");
+        }
+        for r in &radii.radius_xs {
+            assert!(*r >= 0.0, "{name}: negative radius_xs");
+        }
+        for r in &radii.radius_s {
+            assert!(*r >= 0.0, "{name}: negative radius_s");
+        }
+        for r in &radii.radius_m {
+            assert!(*r >= 0.0, "{name}: negative radius_m");
+        }
+        for r in &radii.radius_l {
+            assert!(*r >= 0.0, "{name}: negative radius_l");
+        }
+        for r in &radii.radius_xl {
+            assert!(*r >= 0.0, "{name}: negative radius_xl");
+        }
+    }
+}
+
+#[test]
+fn all_themes_have_non_zero_alpha_accent() {
+    for (name, t) in all_themes() {
+        let accent = &t.accent;
+        assert!(
+            accent.base.alpha > 0.0,
+            "{name}: accent base alpha is zero"
+        );
+    }
+}
+
+#[test]
+fn dark_themes_have_is_dark_set() {
+    assert!(theme::COSMIC_DARK.is_dark);
+    assert!(theme::COSMIC_HC_DARK.is_dark);
+}
+
+#[test]
+fn light_themes_have_is_dark_unset() {
+    assert!(!theme::COSMIC_LIGHT.is_dark);
+    assert!(!theme::COSMIC_HC_LIGHT.is_dark);
+}
+
+#[test]
+fn all_themes_have_non_zero_alpha_on_bg() {
+    for (name, t) in all_themes() {
+        let bg = &t.background;
+        assert!(
+            bg.base.alpha > 0.0,
+            "{name}: background base alpha is zero"
+        );
+    }
+}
+
+#[test]
+fn all_themes_have_non_zero_alpha_on_primary() {
+    for (name, t) in all_themes() {
+        let primary = &t.primary;
+        assert!(
+            primary.base.alpha > 0.0,
+            "{name}: primary base alpha is zero"
+        );
+    }
+}
+
+#[test]
+fn all_themes_have_non_zero_alpha_on_destructive() {
+    for (name, t) in all_themes() {
+        let dest = &t.destructive;
+        assert!(
+            dest.base.alpha > 0.0,
+            "{name}: destructive base alpha is zero"
+        );
+    }
+}
+
+#[test]
+fn all_themes_have_non_zero_alpha_on_warning() {
+    for (name, t) in all_themes() {
+        let warn = &t.warning;
+        assert!(
+            warn.base.alpha > 0.0,
+            "{name}: warning base alpha is zero"
+        );
+    }
+}
+
+#[test]
+fn all_themes_have_non_zero_alpha_on_success() {
+    for (name, t) in all_themes() {
+        let success = &t.success;
+        assert!(
+            success.base.alpha > 0.0,
+            "{name}: success base alpha is zero"
+        );
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Component state consistency tests
+// ---------------------------------------------------------------------------
+
+/// Verify that all states of a Component have non-zero alpha.
+fn assert_component_states_visible(name: &str, variant: &str, component: &cosmic_theme::Component) {
+    assert!(
+        component.base.alpha > 0.0,
+        "{name}/{variant}: base alpha is zero"
+    );
+    // hover/pressed/selected states can have zero alpha in some themes, but
+    // the 'on' color (text on top) should always be visible
+    assert!(
+        component.on.alpha > 0.0,
+        "{name}/{variant}: 'on' (text) alpha is zero"
+    );
+}
+
+#[test]
+fn background_component_states_visible() {
+    for (name, t) in all_themes() {
+        assert_component_states_visible(name, "bg.component", &t.background.component);
+    }
+}
+
+#[test]
+fn primary_component_states_visible() {
+    for (name, t) in all_themes() {
+        assert_component_states_visible(name, "primary.component", &t.primary.component);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Serialization round-trip test
+// ---------------------------------------------------------------------------
+
+#[test]
+fn dark_theme_serializes_to_ron() {
+    let theme = CosmicTheme::dark_default();
+    let serialized = ron::to_string(&theme);
+    assert!(serialized.is_ok(), "Dark theme failed to serialize to RON");
+}
+
+#[test]
+fn light_theme_serializes_to_ron() {
+    let theme = CosmicTheme::light_default();
+    let serialized = ron::to_string(&theme);
+    assert!(serialized.is_ok(), "Light theme failed to serialize to RON");
+}
+
+#[test]
+fn dark_theme_ron_round_trip() {
+    let theme = CosmicTheme::dark_default();
+    let serialized = ron::to_string(&theme).expect("serialize");
+    let deserialized: CosmicTheme = ron::from_str(&serialized).expect("deserialize");
+
+    assert_eq!(theme.is_dark, deserialized.is_dark);
+    assert_eq!(theme.spacing.space_m, deserialized.spacing.space_m);
+}
+
+#[test]
+fn light_theme_ron_round_trip() {
+    let theme = CosmicTheme::light_default();
+    let serialized = ron::to_string(&theme).expect("serialize");
+    let deserialized: CosmicTheme = ron::from_str(&serialized).expect("deserialize");
+
+    assert_eq!(theme.is_dark, deserialized.is_dark);
+    assert_eq!(theme.spacing.space_m, deserialized.spacing.space_m);
+}
+
+// ---------------------------------------------------------------------------
+// Spacing monotonicity
+// ---------------------------------------------------------------------------
+
+#[test]
+fn all_themes_spacing_is_monotonic() {
+    for (name, t) in all_themes() {
+        let s = &t.spacing;
+        assert!(
+            s.space_xxs <= s.space_xs,
+            "{name}: xxs({}) > xs({})",
+            s.space_xxs,
+            s.space_xs
+        );
+        assert!(
+            s.space_xs <= s.space_s,
+            "{name}: xs({}) > s({})",
+            s.space_xs,
+            s.space_s
+        );
+        assert!(
+            s.space_s <= s.space_m,
+            "{name}: s({}) > m({})",
+            s.space_s,
+            s.space_m
+        );
+        assert!(
+            s.space_m <= s.space_l,
+            "{name}: m({}) > l({})",
+            s.space_m,
+            s.space_l
+        );
+        assert!(
+            s.space_l <= s.space_xl,
+            "{name}: l({}) > xl({})",
+            s.space_l,
+            s.space_xl
+        );
+        assert!(
+            s.space_xl <= s.space_xxl,
+            "{name}: xl({}) > xxl({})",
+            s.space_xl,
+            s.space_xxl
+        );
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Corner radii ordering
+// ---------------------------------------------------------------------------
+
+#[test]
+fn all_themes_corner_radii_are_ordered() {
+    for (name, t) in all_themes() {
+        let r = &t.corner_radii;
+        // radius_0 should be all zeros
+        for val in &r.radius_0 {
+            assert_eq!(*val, 0.0, "{name}: radius_0 is not zero");
+        }
+        // Each subsequent radius should be >= the previous (at index 0)
+        assert!(
+            r.radius_xs[0] <= r.radius_s[0],
+            "{name}: radius_xs > radius_s"
+        );
+        assert!(
+            r.radius_s[0] <= r.radius_m[0],
+            "{name}: radius_s > radius_m"
+        );
+        assert!(
+            r.radius_m[0] <= r.radius_l[0],
+            "{name}: radius_m > radius_l"
+        );
+        assert!(
+            r.radius_l[0] <= r.radius_xl[0],
+            "{name}: radius_l > radius_xl"
+        );
+    }
+}