monolith

public

Star0

Fork 0

Watch0

12 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `5a760f013a02`

tarball

atagen <boss@atagen.co>2026-10-16 10:04 UTC

9 files changed+2-318

tests: prune tests that guard nothing tricky

Tests stay only where they pin edge cases, driver quirks, races or invariants that random inputs exercise. Checks of trivially correct code cost build time and churn without catching anything.

Modified file: crates/motion/src/curve.rs−16 deletions@@ -99,22 +99,6 @@ mod tests {
     use proptest::prelude::*;
 
     #[test]
-    fn endpoints_are_exact() {
-        for c in [CubicBezier::LINEAR, CubicBezier::EASE] {
-            assert_eq!(c.sample(0.0), 0.0);
-            assert_eq!(c.sample(1.0), 1.0);
-        }
-    }
-
-    #[test]
-    fn linear_is_identity() {
-        for i in 0..=100 {
-            let t = f64::from(i) / 100.0;
-            assert!((CubicBezier::LINEAR.sample(t) - t).abs() < 1e-6);
-        }
-    }
-
-    #[test]
     fn matched_slope_is_honoured() {
         let c = CubicBezier::EASE.with_initial_slope(2.0);
         assert!((c.initial_slope() - 2.0).abs() < 1e-9);

Modified file: crates/motion/src/timeline.rs−28 deletions@@ -35,31 +35,3 @@ impl Timeline {
         Position::Phase { phase, t }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn locates_phases() {
-        let tl = Timeline {
-            start_ns: 1_000,
-            phase_ns: 100,
-            phases: 3,
-        };
-        assert_eq!(tl.locate(999), Position::NotStarted);
-        assert_eq!(tl.locate(1_000), Position::Phase { phase: 0, t: 0.0 });
-        assert_eq!(tl.locate(1_150), Position::Phase { phase: 1, t: 0.5 });
-        assert_eq!(tl.locate(1_300), Position::Finished);
-    }
-
-    #[test]
-    fn total_time_is_phases_times_duration() {
-        let tl = Timeline {
-            start_ns: 0,
-            phase_ns: 160_000_000,
-            phases: 4,
-        };
-        assert_eq!(tl.end_ns(), 640_000_000);
-    }
-}

Modified file: crates/motion/src/velocity.rs−15 deletions@@ -36,24 +36,9 @@ mod tests {
     use super::*;
 
     #[test]
-    fn continues_same_direction() {
-        let slope = group_initial_slope([([100.0, 100.0, 0.0, 0.0], [50.0, 50.0, 0.0, 0.0])], 0.5);
-        assert_eq!(slope, Some(1.0));
-    }
-
-    #[test]
     fn reversal_starts_from_rest() {
         let slope =
             group_initial_slope([([100.0, 100.0, 0.0, 0.0], [-50.0, -50.0, 0.0, 0.0])], 0.5);
         assert_eq!(slope, None);
     }
-
-    #[test]
-    fn ignores_windows_that_do_not_move_this_phase() {
-        let movers = [
-            ([500.0, 500.0, 0.0, 0.0], [0.0; 4]),
-            ([10.0, 10.0, 0.0, 0.0], [20.0, 20.0, 0.0, 0.0]),
-        ];
-        assert_eq!(group_initial_slope(movers, 1.0), Some(0.5));
-    }
 }

Modified file: crates/planner/src/sat.rs−16 deletions@@ -150,26 +150,10 @@ mod tests {
     use super::*;
 
     #[test]
-    fn satisfiable() {
-        let mut s = TwoSat::new(2);
-        s.either(Lit::new(0, true), Lit::new(1, true));
-        s.either(Lit::new(0, false), Lit::new(1, true));
-        let sol = s.solve().unwrap();
-        assert!(sol[1]);
-    }
-
-    #[test]
     fn unsatisfiable() {
         let mut s = TwoSat::new(1);
         s.require(Lit::new(0, true));
         s.require(Lit::new(0, false));
         assert!(s.solve().is_none());
     }
-
-    #[test]
-    fn preferences_are_kept_when_possible() {
-        let mut s = TwoSat::new(2);
-        s.either(Lit::new(0, false), Lit::new(1, false));
-        assert_eq!(s.solve_preferring(&[true, true]), Some(vec![true, false]));
-    }
 }

Modified file: crates/planner/src/tests.rs−78 deletions@@ -63,16 +63,6 @@ fn strategy(p: &Plan) -> Strategy {
 }
 
 #[test]
-fn swap_uses_two_lanes() {
-    let c = cfg(Style::Orthogonal);
-    let ab = cols(region(), 2);
-    let ba = vec![ab[1], ab[0]];
-    let p = plan(&ab, &ba, &c);
-    assert_clean(&p, &c);
-    assert_eq!(strategy(&p), Strategy::Lanes { lanes: 2 });
-}
-
-#[test]
 fn full_reversal_needs_one_lane_per_window() {
     let c = cfg(Style::Orthogonal);
     let a = cols(region(), 4);
@@ -83,14 +73,6 @@ fn full_reversal_needs_one_lane_per_window() {
 }
 
 #[test]
-fn orientation_flip_is_two_phases() {
-    let c = cfg(Style::Orthogonal);
-    let p = plan(&cols(region(), 3), &rows(region(), 3), &c);
-    assert_clean(&p, &c);
-    assert_eq!(strategy(&p), Strategy::AxisOrder);
-}
-
-#[test]
 fn growing_both_axes_depends_on_style() {
     let grid = |wide: bool| {
         let r = if wide { [7.0, 3.0] } else { [1.0, 1.0] };
@@ -143,24 +125,6 @@ fn insert_and_split_rewinds() {
 }
 
 #[test]
-fn inserting_a_seed_is_one_phase() {
-    let c = cfg(Style::Orthogonal);
-    let three = cols(region(), 3);
-    let four = cols(region(), 4);
-    let seed = Rect::new(
-        (three[1].right() + three[2].x) / 2.0,
-        three[1].y,
-        0.0,
-        three[1].h,
-    );
-    let from = vec![three[0], three[1], three[2], seed];
-    let to = vec![four[0], four[1], four[3], four[2]];
-    let p = plan(&from, &to, &c);
-    assert_clean(&p, &c);
-    assert_eq!(strategy(&p), Strategy::Direct);
-}
-
-#[test]
 fn tag_rows_swap_rigidly_with_two_lanes() {
     let c = cfg(Style::Orthogonal);
     let layout = |first_top: bool| {
@@ -193,22 +157,6 @@ fn simultaneous_reversals_on_both_axes_use_the_grid() {
     assert!(matches!(strategy(&p), Strategy::Grid { .. }));
 }
 
-#[test]
-fn distant_groups_plan_independently() {
-    let c = cfg(Style::Orthogonal);
-    let thirds = cols(region(), 3);
-    let l = rows(thirds[0], 2);
-    let from = vec![l[0], l[1], thirds[1], thirds[2]];
-    let to = vec![l[1], l[0], thirds[1], thirds[2]];
-    let p = plan(&from, &to, &c);
-    assert_clean(&p, &c);
-    assert!(
-        p.groups
-            .iter()
-            .any(|g| g.members == [3] && g.strategy == Strategy::Unchanged)
-    );
-}
-
 struct Rng(u64);
 
 impl Rng {
@@ -303,29 +251,3 @@ proptest! {
         prop_assert_eq!(&second.keyframes[0], &mid);
     }
 }
-
-#[test]
-#[ignore = "statistics, run with --ignored --nocapture"]
-fn strategy_distribution() {
-    use std::collections::BTreeMap;
-    for style in [Style::Orthogonal, Style::Direct] {
-        let c = cfg(style);
-        let mut rng = Rng(0x9e37_79b9_7f4a_7c15);
-        let mut counts: BTreeMap<String, usize> = BTreeMap::new();
-        let mut holes = 0;
-        for _ in 0..20_000 {
-            let n = 2 + rng.below(7);
-            let (a, b) = (random_layout(&mut rng, n), random_layout(&mut rng, n));
-            let p = plan(&a, &b, &c);
-            assert_clean(&p, &c);
-            holes += p.groups.iter().filter(|g| g.opens_hole).count();
-            let key = match strategy(&p) {
-                Strategy::Lanes { .. } => "Lanes".to_string(),
-                Strategy::Grid { .. } => "Grid".to_string(),
-                s => format!("{s:?}"),
-            };
-            *counts.entry(key).or_default() += 1;
-        }
-        println!("{style:?}: {counts:?}, plans opening a hole: {holes}");
-    }
-}

Modified file: crates/planner/src/validate.rs−16 deletions@@ -67,22 +67,6 @@ mod tests {
     use super::*;
 
     #[test]
-    fn crossing_windows_overlap() {
-        let a0 = Rect::new(0.0, 0.0, 100.0, 100.0);
-        let b0 = Rect::new(110.0, 0.0, 100.0, 100.0);
-        assert!(overlaps_during(&a0, &b0, &b0, &a0, 0.5));
-    }
-
-    #[test]
-    fn neighbours_moving_together_do_not() {
-        let a0 = Rect::new(0.0, 0.0, 100.0, 100.0);
-        let a1 = Rect::new(0.0, 0.0, 150.0, 100.0);
-        let b0 = Rect::new(110.0, 0.0, 100.0, 100.0);
-        let b1 = Rect::new(160.0, 0.0, 50.0, 100.0);
-        assert!(!overlaps_during(&a0, &a1, &b0, &b1, 0.5));
-    }
-
-    #[test]
     fn zero_size_seed_inside_a_window_is_not_an_overlap() {
         let a = Rect::new(0.0, 0.0, 100.0, 100.0);
         let seed = Rect::new(50.0, 0.0, 0.0, 100.0);

Modified file: crates/render-vk/src/transform.rs−18 deletions@@ -86,24 +86,6 @@ mod tests {
     use super::*;
 
     #[test]
-    fn identity_covers_the_whole_texture() {
-        let uv = texture_uvs(
-            Rectangle::from_size((4.0, 2.0).into()),
-            (8, 4).into(),
-            (4, 2).into(),
-            Transform::Normal,
-        );
-        assert_eq!(uv, [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]);
-    }
-
-    #[test]
-    fn crop_selects_part_of_the_texture() {
-        let src = Rectangle::new((2.0, 0.0).into(), (2.0, 2.0).into());
-        let uv = texture_uvs(src, (2, 2).into(), (4, 2).into(), Transform::Normal);
-        assert_eq!(uv, [[0.5, 0.0], [1.0, 0.0], [0.5, 1.0], [1.0, 1.0]]);
-    }
-
-    #[test]
     fn rotation_permutes_corners_without_moving_identity_outputs() {
         let dst = Rectangle::new((0, 0).into(), (10, 10).into());
         let uvs = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]];

Modified file: crates/render-vk/tests/dmabuf.rs−25 deletions@@ -55,22 +55,6 @@ fn all_rgba(bytes: &[u8], want: [u8; 4]) -> bool {
 }
 
 #[test]
-fn renders_into_an_allocated_dmabuf_and_reads_it_back() {
-    let Some(mut r) = renderer() else { return };
-    let mut buf = dmabuf(&r);
-    fill(&mut r, &mut buf, [1.0, 0.0, 0.0, 1.0]).wait().unwrap();
-    let target = r.bind(&mut buf).unwrap();
-    let mapping = r
-        .copy_framebuffer(
-            &target,
-            Rectangle::from_size((SIZE, SIZE).into()),
-            Fourcc::Abgr8888,
-        )
-        .unwrap();
-    assert!(all_rgba(r.map_texture(&mapping).unwrap(), [255, 0, 0, 255]));
-}
-
-#[test]
 fn samples_an_imported_dmabuf() {
     let Some(mut r) = renderer() else { return };
     let mut buf = dmabuf(&r);
@@ -109,15 +93,6 @@ fn samples_an_imported_dmabuf() {
 }
 
 #[test]
-fn imports_are_cached_per_buffer() {
-    let Some(mut r) = renderer() else { return };
-    let buf = dmabuf(&r);
-    let a = r.import_dmabuf(&buf, None).unwrap();
-    let b = r.import_dmabuf(&buf, None).unwrap();
-    assert_eq!(format!("{a:?}"), format!("{b:?}"));
-}
-
-#[test]
 fn frame_fences_export_as_sync_files() {
     let Some(mut r) = renderer() else { return };
     let mut buf = dmabuf(&r);

Modified file: crates/render-vk/tests/golden.rs+2 additions−106 deletions@@ -4,9 +4,9 @@
 use monolith_render_vk::{VulkanImage, VulkanRenderer, VulkanTexture};
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::renderer::{
-    Bind, Color32F, ExportMem, Frame, ImportMem, Offscreen, Renderer, TextureFilter,
+    Bind, Color32F, ExportMem, Frame, ImportMem, Offscreen, Renderer,
 };
-use smithay::utils::{Physical, Rectangle, Size, Transform};
+use smithay::utils::{Physical, Rectangle, Transform};
 
 const W: i32 = 64;
 const H: i32 = 64;
@@ -15,7 +15,6 @@ type Pixel = [u8; 4];
 
 const RED: Pixel = [255, 0, 0, 255];
 const GREEN: Pixel = [0, 255, 0, 255];
-const BLUE: Pixel = [0, 0, 255, 255];
 const WHITE: Pixel = [255, 255, 255, 255];
 const BLACK: Pixel = [0, 0, 0, 255];
 
@@ -87,45 +86,6 @@ fn rgba(p: Pixel) -> Color32F {
 }
 
 #[test]
-fn clears_to_a_colour() {
-    let mut s = Scene::new();
-    s.draw(Transform::Normal, |f| {
-        f.clear(rgba(RED), &[full()]).unwrap()
-    });
-    let px = s.pixels();
-    assert!(px.iter().all(|&p| p == RED));
-}
-
-#[test]
-fn solid_fill_respects_its_rectangle() {
-    let mut s = Scene::new();
-    s.draw(Transform::Normal, |f| {
-        f.clear(rgba(BLACK), &[full()]).unwrap();
-        let dst = Rectangle::new((16, 16).into(), (32, 32).into());
-        f.draw_solid(dst, &[Rectangle::from_size(dst.size)], rgba(GREEN))
-            .unwrap();
-    });
-    let px = s.pixels();
-    assert_eq!(at(&px, 16, 16), GREEN);
-    assert_eq!(at(&px, 47, 47), GREEN);
-    assert_eq!(at(&px, 15, 16), BLACK);
-    assert_eq!(at(&px, 48, 47), BLACK);
-}
-
-#[test]
-fn damage_limits_drawing() {
-    let mut s = Scene::new();
-    s.draw(Transform::Normal, |f| {
-        f.clear(rgba(BLACK), &[full()]).unwrap();
-        let damage = Rectangle::new((0, 0).into(), (8, 8).into());
-        f.draw_solid(full(), &[damage], rgba(BLUE)).unwrap();
-    });
-    let px = s.pixels();
-    assert_eq!(at(&px, 7, 7), BLUE);
-    assert_eq!(at(&px, 8, 8), BLACK);
-}
-
-#[test]
 fn partial_clear_keeps_previous_contents() {
     let mut s = Scene::new();
     s.draw(Transform::Normal, |f| {
@@ -144,30 +104,6 @@ fn partial_clear_keeps_previous_contents() {
 }
 
 #[test]
-fn textures_sample_with_nearest_filtering() {
-    let mut s = Scene::new();
-    s.renderer.upscale_filter(TextureFilter::Nearest).unwrap();
-    let tex = s.texture((2, 2), &[RED, GREEN, BLUE, WHITE]);
-    s.draw(Transform::Normal, |f| {
-        f.render_texture_from_to(
-            &tex,
-            Rectangle::from_size((2.0, 2.0).into()),
-            full(),
-            &[full()],
-            &[],
-            Transform::Normal,
-            1.0,
-        )
-        .unwrap();
-    });
-    let px = s.pixels();
-    assert_eq!(at(&px, 8, 8), RED);
-    assert_eq!(at(&px, 56, 8), GREEN);
-    assert_eq!(at(&px, 8, 56), BLUE);
-    assert_eq!(at(&px, 56, 56), WHITE);
-}
-
-#[test]
 fn alpha_blends_premultiplied() {
     let mut s = Scene::new();
     let tex = s.texture((1, 1), &[WHITE]);
@@ -206,46 +142,6 @@ fn output_transform_moves_content() {
 }
 
 #[test]
-fn offscreen_images_can_be_sampled() {
-    let mut s = Scene::new();
-    let mut inner = s
-        .renderer
-        .create_buffer(Fourcc::Argb8888, Size::from((4, 4)))
-        .unwrap();
-    {
-        let mut t = s.renderer.bind(&mut inner).unwrap();
-        let mut f = s
-            .renderer
-            .render(&mut t, (4, 4).into(), Transform::Normal)
-            .unwrap();
-        f.clear(rgba(BLUE), &[Rectangle::from_size((4, 4).into())])
-            .unwrap();
-        f.finish().unwrap().wait().unwrap();
-    }
-    let tex = inner.texture();
-    s.draw(Transform::Normal, |f| {
-        f.render_texture_from_to(
-            &tex,
-            Rectangle::from_size((4.0, 4.0).into()),
-            full(),
-            &[full()],
-            &[],
-            Transform::Normal,
-            1.0,
-        )
-        .unwrap();
-    });
-    assert_eq!(at(&s.pixels(), 32, 32), BLUE);
-}
-
-#[test]
-fn reports_the_device() {
-    let r = VulkanRenderer::new().unwrap();
-    eprintln!("rendering on {}", r.device_name());
-    assert!(!r.device_name().is_empty());
-}
-
-#[test]
 fn solid_fill_in_the_corner_keeps_its_colour() {
     let mut s = Scene::new();
     s.draw(Transform::Normal, |f| {

monolith

Commit 5a760f013a02

Commit `5a760f013a02`