Implement Heatmap and BoxPlot chart types with comprehensive TDD

- Add ChartType::Heatmap and ChartType::BoxPlot variants
- Implement paint_heatmap() for matrix data visualization
- Implement paint_boxplot() for statistical distributions
- Add Chart::heatmap() and Chart::boxplot() constructors
- Add comprehensive tests across all widget modules:
  - presentar-core/widget.rs: 15 new tests
  - presentar-test/bdd.rs: 14 new tests
  - presentar-widgets/chart.rs: Tests for new chart types
  - presentar-widgets/data_card.rs: 8 new tests
  - presentar-widgets/model_card.rs: 7 new tests
  - presentar-widgets/list.rs: 14 new tests
  - presentar-widgets/menu.rs: 28 new tests
  - presentar-widgets/modal.rs: 14 new tests
  - presentar-yaml/error.rs: 9 new tests

Coverage: 89.14% | Lint: Clean

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: noahgift

crates/presentar-core/src/widget.rs

@@ -371,6 +371,25 @@ mod tests {
         assert_eq!(id.0, 42);
     }
 
+    #[test]
+    fn test_widget_id_eq() {
+        let id1 = WidgetId::new(1);
+        let id2 = WidgetId::new(1);
+        let id3 = WidgetId::new(2);
+        assert_eq!(id1, id2);
+        assert_ne!(id1, id3);
+    }
+
+    #[test]
+    fn test_widget_id_hash() {
+        use std::collections::HashSet;
+        let mut set = HashSet::new();
+        set.insert(WidgetId::new(1));
+        set.insert(WidgetId::new(2));
+        assert_eq!(set.len(), 2);
+        assert!(set.contains(&WidgetId::new(1)));
+    }
+
     #[test]
     fn test_type_id() {
         let id1 = TypeId::of::<u32>();
@@ -381,12 +400,27 @@ mod tests {
         assert_ne!(id1, id3);
     }
 
+    #[test]
+    fn test_type_id_hash() {
+        use std::collections::HashSet;
+        let mut set = HashSet::new();
+        set.insert(TypeId::of::<u32>());
+        set.insert(TypeId::of::<String>());
+        assert_eq!(set.len(), 2);
+    }
+
     #[test]
     fn test_transform2d_identity() {
         let t = Transform2D::IDENTITY;
         assert_eq!(t.matrix, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]);
     }
 
+    #[test]
+    fn test_transform2d_default() {
+        let t = Transform2D::default();
+        assert_eq!(t.matrix, Transform2D::IDENTITY.matrix);
+    }
+
     #[test]
     fn test_transform2d_translate() {
         let t = Transform2D::translate(10.0, 20.0);
@@ -401,15 +435,109 @@ mod tests {
         assert_eq!(t.matrix[3], 3.0);
     }
 
+    #[test]
+    fn test_transform2d_rotate() {
+        let t = Transform2D::rotate(std::f32::consts::PI / 2.0);
+        // 90 degrees rotation: cos = 0, sin = 1
+        assert!((t.matrix[0] - 0.0).abs() < 1e-6);
+        assert!((t.matrix[1] - 1.0).abs() < 1e-6);
+        assert!((t.matrix[2] - (-1.0)).abs() < 1e-6);
+        assert!((t.matrix[3] - 0.0).abs() < 1e-6);
+    }
+
     #[test]
     fn test_text_style_default() {
         let style = TextStyle::default();
         assert_eq!(style.size, 16.0);
         assert_eq!(style.weight, FontWeight::Normal);
+        assert_eq!(style.style, FontStyle::Normal);
+        assert_eq!(style.color, crate::Color::BLACK);
+    }
+
+    #[test]
+    fn test_text_style_eq() {
+        let s1 = TextStyle::default();
+        let s2 = TextStyle::default();
+        assert_eq!(s1, s2);
+    }
+
+    #[test]
+    fn test_text_style_custom() {
+        let style = TextStyle {
+            size: 24.0,
+            color: crate::Color::RED,
+            weight: FontWeight::Bold,
+            style: FontStyle::Italic,
+        };
+        assert_eq!(style.size, 24.0);
+        assert_eq!(style.weight, FontWeight::Bold);
+        assert_eq!(style.style, FontStyle::Italic);
+    }
+
+    #[test]
+    fn test_font_weight_variants() {
+        let weights = [
+            FontWeight::Thin,
+            FontWeight::Light,
+            FontWeight::Normal,
+            FontWeight::Medium,
+            FontWeight::Semibold,
+            FontWeight::Bold,
+            FontWeight::Black,
+        ];
+        assert_eq!(weights.len(), 7);
+    }
+
+    #[test]
+    fn test_font_style_variants() {
+        assert_ne!(FontStyle::Normal, FontStyle::Italic);
     }
 
     #[test]
     fn test_accessible_role_default() {
         assert_eq!(AccessibleRole::default(), AccessibleRole::Generic);
     }
+
+    #[test]
+    fn test_accessible_role_variants() {
+        let roles = [
+            AccessibleRole::Generic,
+            AccessibleRole::Button,
+            AccessibleRole::Checkbox,
+            AccessibleRole::TextInput,
+            AccessibleRole::Link,
+            AccessibleRole::Heading,
+            AccessibleRole::Image,
+            AccessibleRole::List,
+            AccessibleRole::ListItem,
+            AccessibleRole::Table,
+            AccessibleRole::TableRow,
+            AccessibleRole::TableCell,
+            AccessibleRole::Menu,
+            AccessibleRole::MenuItem,
+            AccessibleRole::ComboBox,
+            AccessibleRole::Slider,
+            AccessibleRole::ProgressBar,
+            AccessibleRole::Tab,
+            AccessibleRole::TabPanel,
+            AccessibleRole::RadioGroup,
+            AccessibleRole::Radio,
+        ];
+        assert_eq!(roles.len(), 21);
+    }
+
+    #[test]
+    fn test_layout_result_default() {
+        let result = LayoutResult::default();
+        assert_eq!(result.size, Size::new(0.0, 0.0));
+    }
+
+    #[test]
+    fn test_layout_result_with_size() {
+        let result = LayoutResult {
+            size: Size::new(100.0, 50.0),
+        };
+        assert_eq!(result.size.width, 100.0);
+        assert_eq!(result.size.height, 50.0);
+    }
 }

crates/presentar-test/src/bdd.rs

@@ -595,4 +595,87 @@ mod tests {
 
         assert!(outer.all_passed());
     }
+
+    // =========================================================================
+    // Additional Coverage Tests
+    // =========================================================================
+
+    #[test]
+    fn test_expect_string_owned_to_contain() {
+        expect("hello world".to_string()).to_contain("world");
+    }
+
+    #[test]
+    fn test_expect_string_owned_to_be_empty() {
+        expect(String::new()).to_be_empty();
+    }
+
+    #[test]
+    fn test_expect_string_owned_not_empty() {
+        expect("hello".to_string()).not().to_be_empty();
+    }
+
+    #[test]
+    fn test_expect_f32_close_to_negated() {
+        expect(10.0_f32).not().to_be_close_to(1.0, 0.1);
+    }
+
+    #[test]
+    fn test_expect_f64_close_to_negated() {
+        expect(10.0_f64).not().to_be_close_to(1.0, 0.1);
+    }
+
+    #[test]
+    fn test_expect_str_not_start_with() {
+        expect("hello").not().to_start_with("xyz");
+    }
+
+    #[test]
+    fn test_expect_str_not_end_with() {
+        expect("hello").not().to_end_with("xyz");
+    }
+
+    #[test]
+    fn test_expect_option_negated() {
+        expect(Some(42)).not().to_be_none();
+        expect(None::<i32>).not().to_be_some();
+    }
+
+    #[test]
+    fn test_expect_result_negated() {
+        expect(Ok::<i32, &str>(42)).not().to_be_err();
+        expect(Err::<i32, &str>("error")).not().to_be_ok();
+    }
+
+    #[test]
+    fn test_expect_vec_not_length() {
+        expect(vec![1, 2, 3]).not().to_have_length(5);
+    }
+
+    #[test]
+    fn test_expect_bool_negated() {
+        expect(true).not().to_be_false();
+        expect(false).not().to_be_true();
+    }
+
+    #[test]
+    fn test_expect_comparison_negated() {
+        expect(3).not().to_be_greater_than(10);
+        expect(10).not().to_be_less_than(3);
+    }
+
+    #[test]
+    fn test_expect_equality_negated() {
+        expect(1).not().to_equal(2);
+    }
+
+    #[test]
+    fn test_context_passed_plus_failed() {
+        let ctx = describe("Test", |ctx| {
+            ctx.it("pass1", |_| {});
+            ctx.it("pass2", |_| {});
+            ctx.it("fail", |_| { expect(1).to_equal(2); });
+        });
+        assert_eq!(ctx.passed() + ctx.failed(), 3);
+    }
 }