tawasuyu/taffy

1#[cfg(test)]
2mod root_constraints {
3    use taffy::prelude::{FromLength, FromPercent};
4    use taffy::style_helpers::{length, TaffyMaxContent};
5    use taffy::{AvailableSpace, Rect, Size, Style, TaffyTree};
6    use taffy_test_helpers::new_test_tree;
7
8    #[test]
9    fn root_with_percentage_size() {
10        let mut taffy = new_test_tree();
11        let node = taffy
12            .new_leaf(taffy::style::Style {
13                size: taffy::geometry::Size {
14                    width: taffy::style::Dimension::from_percent(1.0),
15                    height: taffy::style::Dimension::from_percent(1.0),
16                },
17                ..Default::default()
18            })
19            .unwrap();
20
21        taffy
22            .compute_layout(
23                node,
24                taffy::geometry::Size {
25                    width: AvailableSpace::Definite(100.0),
26                    height: AvailableSpace::Definite(200.0),
27                },
28            )
29            .unwrap();
30        let layout = taffy.layout(node).unwrap();
31
32        assert_eq!(layout.size.width, 100.0);
33        assert_eq!(layout.size.height, 200.0);
34    }
35
36    #[test]
37    fn root_with_no_size() {
38        let mut taffy = new_test_tree();
39        let node = taffy.new_leaf(taffy::style::Style::default()).unwrap();
40
41        taffy
42            .compute_layout(
43                node,
44                taffy::geometry::Size {
45                    width: AvailableSpace::Definite(100.0),
46                    height: AvailableSpace::Definite(100.0),
47                },
48            )
49            .unwrap();
50        let layout = taffy.layout(node).unwrap();
51
52        assert_eq!(layout.size.width, 0.0);
53        assert_eq!(layout.size.height, 0.0);
54    }
55
56    #[test]
57    fn root_with_larger_size() {
58        let mut taffy = new_test_tree();
59        let node = taffy
60            .new_leaf(taffy::style::Style {
61                size: taffy::geometry::Size {
62                    width: taffy::style::Dimension::from_length(200.0),
63                    height: taffy::style::Dimension::from_length(200.0),
64                },
65                ..Default::default()
66            })
67            .unwrap();
68
69        taffy
70            .compute_layout(
71                node,
72                taffy::geometry::Size {
73                    width: AvailableSpace::Definite(100.0),
74                    height: AvailableSpace::Definite(100.0),
75                },
76            )
77            .unwrap();
78        let layout = taffy.layout(node).unwrap();
79
80        assert_eq!(layout.size.width, 200.0);
81        assert_eq!(layout.size.height, 200.0);
82    }
83
84    #[test]
85    fn root_padding_and_border_larger_than_definite_size() {
86        let mut tree: TaffyTree<()> = TaffyTree::with_capacity(16);
87
88        let child = tree.new_leaf(Style::default()).unwrap();
89
90        let root = tree
91            .new_with_children(
92                Style {
93                    size: Size { width: length(10.0), height: length(10.0) },
94                    padding: Rect { left: length(10.0), right: length(10.0), top: length(10.0), bottom: length(10.0) },
95
96                    border: Rect { left: length(10.0), right: length(10.0), top: length(10.0), bottom: length(10.0) },
97                    ..Default::default()
98                },
99                &[child],
100            )
101            .unwrap();
102
103        tree.compute_layout(root, Size::MAX_CONTENT).unwrap();
104
105        let layout = tree.layout(root).unwrap();
106
107        assert_eq!(layout.size.width, 40.0);
108        assert_eq!(layout.size.height, 40.0);
109    }
110}