Add 49 headless unit tests and fix text_editor backspace/delete bug

Tests cover text_editor (cursor, selection, keys, multiline), tap
(touch events), list (all orientations), shapes (layout, hittest),
padding, size, offset, cond, emptyview, and spacer.

Fix: backspace/delete with active selection was double-deleting because
delete_selection() cleared the selection state before the check.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: wtholliday

src/views/cond.rs

@@ -126,3 +126,50 @@ pub fn cond(cond: bool, if_true: impl View, if_false: impl View) -> impl View {
         if_false,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cond_true_uses_first_view() {
+        let mut cx = Context::new();
+        let ui = cond(
+            true,
+            rectangle().size([50.0, 50.0]),
+            rectangle().size([100.0, 100.0]),
+        );
+        let sz = [200.0, 200.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        assert_eq!(result, [50.0, 50.0].into());
+    }
+
+    #[test]
+    fn test_cond_false_uses_second_view() {
+        let mut cx = Context::new();
+        let ui = cond(
+            false,
+            rectangle().size([50.0, 50.0]),
+            rectangle().size([100.0, 100.0]),
+        );
+        let sz = [200.0, 200.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        assert_eq!(result, [100.0, 100.0].into());
+    }
+}

src/views/emptyview.rs

@@ -11,3 +11,25 @@ impl DynView for EmptyView {
 }
 
 impl private::Sealed for EmptyView {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_emptyview_zero_size() {
+        let mut cx = Context::new();
+        let ui = EmptyView {};
+        let sz = [100.0, 100.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        assert_eq!(result, [0.0, 0.0].into());
+    }
+}

src/views/list.rs

@@ -272,3 +272,104 @@ pub fn zlist<ID: Hash + Clone, V: View, F: Fn(&ID) -> V + Clone + 'static>(
         func: f,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_vertical_list_layout() {
+        let mut cx = Context::new();
+        let ui = list(vec![0, 1, 2], |_id| rectangle().size([40.0, 20.0]));
+        let sz = [200.0, 200.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        // 3 items each 20px tall, max width 40
+        assert_eq!(result.width, 40.0);
+        assert_eq!(result.height, 60.0);
+    }
+
+    #[test]
+    fn test_horizontal_list_layout() {
+        let mut cx = Context::new();
+        let ui = hlist(vec![0, 1, 2], |_id| rectangle().size([30.0, 50.0]));
+        let sz = [200.0, 200.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        // 3 items each 30px wide, max height 50
+        assert_eq!(result.width, 90.0);
+        assert_eq!(result.height, 50.0);
+    }
+
+    #[test]
+    fn test_z_list_layout() {
+        let mut cx = Context::new();
+        let ui = zlist(vec![0, 1], |_id| rectangle());
+        let sz = [100.0, 80.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        // Z layout returns the proposed size
+        assert_eq!(result, sz);
+    }
+
+    #[test]
+    fn test_list_empty() {
+        let mut cx = Context::new();
+        let ui = list(Vec::<i32>::new(), |_id| rectangle());
+        let sz = [100.0, 100.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        assert_eq!(result.width, 0.0);
+        assert_eq!(result.height, 0.0);
+    }
+
+    #[test]
+    fn test_vertical_list_varying_heights() {
+        let mut cx = Context::new();
+        let ui = list(vec![0, 1, 2], |id| {
+            let h = (*id + 1) as f32 * 10.0;
+            rectangle().size([50.0, h])
+        });
+        let sz = [200.0, 200.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        // Heights: 10 + 20 + 30 = 60
+        assert_eq!(result.height, 60.0);
+        assert_eq!(result.width, 50.0);
+    }
+}

src/views/offset.rs

@@ -89,3 +89,47 @@ where
 }
 
 impl<V> private::Sealed for Offset<V> {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_offset_preserves_size() {
+        let mut cx = Context::new();
+        let ui = Offset::new(rectangle(), [10.0, 20.0].into());
+        let sz = [100.0, 100.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        // Offset doesn't change the layout size
+        assert_eq!(result, sz);
+    }
+
+    #[test]
+    fn test_offset_shifts_hittest() {
+        let mut cx = Context::new();
+        let ui = Offset::new(rectangle(), [50.0, 50.0].into());
+        let sz = [100.0, 100.0].into();
+        let mut path = vec![0];
+        ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        // The rectangle is offset by (50,50), so point (25,25) maps to (-25,-25) in child space
+        // which is outside the 100x100 rect
+        assert!(ui.hittest(&mut path, [25.0, 25.0].into(), &mut cx).is_none());
+        // Point (75,75) maps to (25,25) in child space, which is inside
+        assert!(ui.hittest(&mut path, [75.0, 75.0].into(), &mut cx).is_some());
+    }
+}

src/views/padding.rs

@@ -120,3 +120,64 @@ where
 }
 
 impl<V> private::Sealed for Padding<V> {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_padding_increases_size() {
+        let mut cx = Context::new();
+        let ui = Padding::new(rectangle(), PaddingParam::Px(10.0));
+        let sz = [100.0, 100.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        // rectangle fills available space (100-20=80), then padding adds 20 back
+        assert_eq!(result, [100.0, 100.0].into());
+    }
+
+    #[test]
+    fn test_padding_auto() {
+        let mut cx = Context::new();
+        let ui = Padding::new(rectangle(), PaddingParam::Auto);
+        let sz = [50.0, 50.0].into();
+        let mut path = vec![0];
+        let result = ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        // Auto padding is 5.0, so child gets 40x40, result is 50x50
+        assert_eq!(result, [50.0, 50.0].into());
+    }
+
+    #[test]
+    fn test_padding_hittest_offsets() {
+        let mut cx = Context::new();
+        let ui = Padding::new(rectangle(), PaddingParam::Px(20.0));
+        let sz = [100.0, 100.0].into();
+        let mut path = vec![0];
+        ui.layout(
+            &mut path,
+            &mut LayoutArgs {
+                sz,
+                cx: &mut cx,
+                text_bounds: &mut |_, _, _| LocalRect::zero(),
+            },
+        );
+        // Point inside the padded child area (child starts at 20,20)
+        assert!(ui.hittest(&mut path, [50.0, 50.0].into(), &mut cx).is_some());
+        // Point in the padding area (outside child)
+        assert!(ui.hittest(&mut path, [5.0, 5.0].into(), &mut cx).is_none());
+    }
+}