Delta semántico · 29
tests/root_constraints.rs
diff --git a/tests/measure.rs b/tests/measure.rs
index a5f3fb7f0..e15dd6c1d 100644
--- a/tests/measure.rs
+++ b/tests/measure.rs
@@ -4,7 +4,8 @@ mod measure {
#[test]
fn measure_root() {
- let layout = stretch::node::Node::new_leaf(
+ let mut stretch = stretch::node::Stretch::new();
+ let node = stretch.new_leaf(
stretch::style::Style { ..Default::default() },
Box::new(|constraint| {
Ok(stretch::geometry::Size {
@@ -12,487 +13,526 @@ mod measure {
height: constraint.height.or_else(100.0),
})
}),
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
+ );
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
- assert_eq!(layout.size.width, 100.0);
- assert_eq!(layout.size.height, 100.0);
+ assert_eq!(stretch.layout(node).unwrap().size.width, 100.0);
+ assert_eq!(stretch.layout(node).unwrap().size.height, 100.0);
}
#[test]
fn measure_child() {
- let layout = stretch::node::Node::new(
+ let mut stretch = stretch::node::Stretch::new();
+
+ let child = stretch.new_leaf(
stretch::style::Style { ..Default::default() },
- vec![&stretch::node::Node::new_leaf(
- stretch::style::Style { ..Default::default() },
- Box::new(|constraint| {
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(100.0),
- height: constraint.height.or_else(100.0),
- })
- }),
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.size.width, 100.0);
- assert_eq!(layout.size.height, 100.0);
-
- assert_eq!(layout.children[0].size.width, 100.0);
- assert_eq!(layout.children[0].size.height, 100.0);
+ Box::new(|constraint| {
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(100.0),
+ height: constraint.height.or_else(100.0),
+ })
+ }),
+ );
+ let node = stretch.new_node(stretch::style::Style { ..Default::default() }, vec![child]).unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(node).unwrap().size.width, 100.0);
+ assert_eq!(stretch.layout(node).unwrap().size.height, 100.0);
+
+ assert_eq!(stretch.layout(child).unwrap().size.width, 100.0);
+ assert_eq!(stretch.layout(child).unwrap().size.height, 100.0);
}
#[test]
fn measure_child_constraint() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size { width: stretch::style::Dimension::Points(50.0), ..Default::default() },
- ..Default::default()
- },
- vec![&stretch::node::Node::new_leaf(
- stretch::style::Style { ..Default::default() },
- Box::new(|constraint| {
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(100.0),
- height: constraint.height.or_else(100.0),
- })
- }),
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.size.width, 50.0);
- assert_eq!(layout.size.height, 100.0);
-
- assert_eq!(layout.children[0].size.width, 50.0);
- assert_eq!(layout.children[0].size.height, 100.0);
+ let mut stretch = stretch::node::Stretch::new();
+ let child = stretch.new_leaf(
+ stretch::style::Style { ..Default::default() },
+ Box::new(|constraint| {
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(100.0),
+ height: constraint.height.or_else(100.0),
+ })
+ }),
+ );
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(50.0),
+ ..Default::default()
+ },
+ ..Default::default()
+ },
+ vec![child],
+ )
+ .unwrap();
+
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(node).unwrap().size.width, 50.0);
+ assert_eq!(stretch.layout(node).unwrap().size.height, 100.0);
+
+ assert_eq!(stretch.layout(child).unwrap().size.width, 50.0);
+ assert_eq!(stretch.layout(child).unwrap().size.height, 100.0);
}
#[test]
fn measure_child_constraint_padding_parent() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size { width: stretch::style::Dimension::Points(50.0), ..Default::default() },
- padding: stretch::geometry::Rect {
- start: stretch::style::Dimension::Points(10.0),
- end: stretch::style::Dimension::Points(10.0),
- top: stretch::style::Dimension::Points(10.0),
- bottom: stretch::style::Dimension::Points(10.0),
+ let mut stretch = stretch::node::Stretch::new();
+ let child = stretch.new_leaf(
+ stretch::style::Style { ..Default::default() },
+ Box::new(|constraint| {
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(100.0),
+ height: constraint.height.or_else(100.0),
+ })
+ }),
+ );
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(50.0),
+ ..Default::default()
+ },
+ padding: stretch::geometry::Rect {
+ start: stretch::style::Dimension::Points(10.0),
+ end: stretch::style::Dimension::Points(10.0),
+ top: stretch::style::Dimension::Points(10.0),
+ bottom: stretch::style::Dimension::Points(10.0),
+ },
+ ..Default::default()
},
- ..Default::default()
- },
- vec![&stretch::node::Node::new_leaf(
- stretch::style::Style { ..Default::default() },
- Box::new(|constraint| {
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(100.0),
- height: constraint.height.or_else(100.0),
- })
- }),
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.size.width, 50.0);
- assert_eq!(layout.size.height, 120.0);
-
- assert_eq!(layout.children[0].size.width, 30.0);
- assert_eq!(layout.children[0].size.height, 100.0);
+ vec![child],
+ )
+ .unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(node).unwrap().size.width, 50.0);
+ assert_eq!(stretch.layout(node).unwrap().size.height, 120.0);
+
+ assert_eq!(stretch.layout(child).unwrap().size.width, 30.0);
+ assert_eq!(stretch.layout(child).unwrap().size.height, 100.0);
}
#[test]
fn measure_child_with_flex_grow() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0), ..Default::default() },
- ..Default::default()
- },
- vec![
- &stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(50.0),
- height: stretch::style::Dimension::Points(50.0),
- },
+ let mut stretch = stretch::node::Stretch::new();
+ let child0 = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(50.0),
+ height: stretch::style::Dimension::Points(50.0),
+ },
+ ..Default::default()
+ },
+ vec![],
+ )
+ .unwrap();
+ let child1 = stretch.new_leaf(
+ stretch::style::Style { flex_grow: 1.0, ..Default::default() },
+ Box::new(|constraint| {
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(10.0),
+ height: constraint.height.or_else(50.0),
+ })
+ }),
+ );
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(100.0),
..Default::default()
},
- vec![],
- ),
- &stretch::node::Node::new_leaf(
- stretch::style::Style { flex_grow: 1.0, ..Default::default() },
- Box::new(|constraint| {
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(10.0),
- height: constraint.height.or_else(50.0),
- })
- }),
- ),
- ],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[1].size.width, 50.0);
- assert_eq!(layout.children[1].size.height, 50.0);
+ ..Default::default()
+ },
+ vec![child0, child1],
+ )
+ .unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child1).unwrap().size.width, 50.0);
+ assert_eq!(stretch.layout(child1).unwrap().size.height, 50.0);
}
#[test]
fn measure_child_with_flex_shrink() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0), ..Default::default() },
- ..Default::default()
- },
- vec![
- &stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(50.0),
- height: stretch::style::Dimension::Points(50.0),
- },
- flex_shrink: 0.0,
+ let mut stretch = stretch::node::Stretch::new();
+ let child0 = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(50.0),
+ height: stretch::style::Dimension::Points(50.0),
+ },
+ flex_shrink: 0.0,
+ ..Default::default()
+ },
+ vec![],
+ )
+ .unwrap();
+ let child1 = stretch.new_leaf(
+ stretch::style::Style { ..Default::default() },
+ Box::new(|constraint| {
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(100.0),
+ height: constraint.height.or_else(50.0),
+ })
+ }),
+ );
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(100.0),
..Default::default()
},
- vec![],
- ),
- &stretch::node::Node::new_leaf(
- stretch::style::Style { ..Default::default() },
- Box::new(|constraint| {
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(100.0),
- height: constraint.height.or_else(50.0),
- })
- }),
- ),
- ],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[1].size.width, 50.0);
- assert_eq!(layout.children[1].size.height, 50.0);
+ ..Default::default()
+ },
+ vec![child0, child1],
+ )
+ .unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child1).unwrap().size.width, 50.0);
+ assert_eq!(stretch.layout(child1).unwrap().size.height, 50.0);
}
#[test]
fn remeasure_child_after_growing() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0), ..Default::default() },
- align_items: stretch::style::AlignItems::FlexStart,
- ..Default::default()
- },
- vec![
- &stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(50.0),
- height: stretch::style::Dimension::Points(50.0),
- },
+ let mut stretch = stretch::node::Stretch::new();
+ let child0 = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(50.0),
+ height: stretch::style::Dimension::Points(50.0),
+ },
+ ..Default::default()
+ },
+ vec![],
+ )
+ .unwrap();
+ let child1 = stretch.new_leaf(
+ stretch::style::Style { flex_grow: 1.0, ..Default::default() },
+ Box::new(|constraint| {
+ let width = constraint.width.or_else(10.0);
+ let height = constraint.height.or_else(width * 2.0);
+ Ok(stretch::geometry::Size { width, height })
+ }),
+ );
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(100.0),
..Default::default()
},
- vec![],
- ),
- &stretch::node::Node::new_leaf(
- stretch::style::Style { flex_grow: 1.0, ..Default::default() },
- Box::new(|constraint| {
- let width = constraint.width.or_else(10.0);
- let height = constraint.height.or_else(width * 2.0);
- Ok(stretch::geometry::Size { width, height })
- }),
- ),
- ],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[1].size.width, 50.0);
- assert_eq!(layout.children[1].size.height, 100.0);
+ align_items: stretch::style::AlignItems::FlexStart,
+ ..Default::default()
+ },
+ vec![child0, child1],
+ )
+ .unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child1).unwrap().size.width, 50.0);
+ assert_eq!(stretch.layout(child1).unwrap().size.height, 100.0);
}
#[test]
fn remeasure_child_after_shrinking() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0), ..Default::default() },
- align_items: stretch::style::AlignItems::FlexStart,
- ..Default::default()
- },
- vec![
- &stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(50.0),
- height: stretch::style::Dimension::Points(50.0),
- },
- flex_shrink: 0.0,
- ..Default::default()
+ let mut stretch = stretch::node::Stretch::new();
+ let child0 = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(50.0),
+ height: stretch::style::Dimension::Points(50.0),
},
- vec![],
- ),
- &stretch::node::Node::new_leaf(
- stretch::style::Style { ..Default::default() },
- Box::new(|constraint| {
- let width = constraint.width.or_else(100.0);
- let height = constraint.height.or_else(width * 2.0);
- Ok(stretch::geometry::Size { width, height })
- }),
- ),
- ],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[1].size.width, 50.0);
- assert_eq!(layout.children[1].size.height, 100.0);
- }
-
- #[test]
- fn remeasure_child_after_stretching() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(100.0),
- height: stretch::style::Dimension::Points(100.0),
+ flex_shrink: 0.0,
+ ..Default::default()
},
- ..Default::default()
- },
- vec![&stretch::node::Node::new_leaf(
- stretch::style::Style { ..Default::default() },
- Box::new(|constraint| {
- let height = constraint.height.or_else(50.0);
- let width = constraint.width.or_else(height);
- Ok(stretch::geometry::Size { width, height })
- }),
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[0].size.width, 100.0);
- assert_eq!(layout.children[0].size.height, 100.0);
- }
-
- #[test]
- fn width_overrides_measure() {
- let layout = stretch::node::Node::new(
+ vec![],
+ )
+ .unwrap();
+ let child1 = stretch.new_leaf(
stretch::style::Style { ..Default::default() },
- vec![&stretch::node::Node::new_leaf(
+ Box::new(|constraint| {
+ let width = constraint.width.or_else(100.0);
+ let height = constraint.height.or_else(width * 2.0);
+ Ok(stretch::geometry::Size { width, height })
+ }),
+ );
+ let node = stretch
+ .new_node(
stretch::style::Style {
size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(50.0),
+ width: stretch::style::Dimension::Points(100.0),
..Default::default()
},
+ align_items: stretch::style::AlignItems::FlexStart,
..Default::default()
},
- Box::new(|constraint| {
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(100.0),
- height: constraint.height.or_else(100.0),
- })
- }),
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[0].size.width, 50.0);
- assert_eq!(layout.children[0].size.height, 100.0);
+ vec![child0, child1],
+ )
+ .unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child1).unwrap().size.width, 50.0);
+ assert_eq!(stretch.layout(child1).unwrap().size.height, 100.0);
}
#[test]
- fn height_overrides_measure() {
- let layout = stretch::node::Node::new(
+ fn remeasure_child_after_stretching() {
+ let mut stretch = stretch::node::Stretch::new();
+ let child = stretch.new_leaf(
stretch::style::Style { ..Default::default() },
- vec![&stretch::node::Node::new_leaf(
+ Box::new(|constraint| {
+ let height = constraint.height.or_else(50.0);
+ let width = constraint.width.or_else(height);
+ Ok(stretch::geometry::Size { width, height })
+ }),
+ );
+ let node = stretch
+ .new_node(
stretch::style::Style {
size: stretch::geometry::Size {
- height: stretch::style::Dimension::Points(50.0),
- ..Default::default()
+ width: stretch::style::Dimension::Points(100.0),
+ height: stretch::style::Dimension::Points(100.0),
},
..Default::default()
},
- Box::new(|constraint| {
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(100.0),
- height: constraint.height.or_else(100.0),
- })
- }),
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[0].size.width, 100.0);
- assert_eq!(layout.children[0].size.height, 50.0);
+ vec![child],
+ )
+ .unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child).unwrap().size.width, 100.0);
+ assert_eq!(stretch.layout(child).unwrap().size.height, 100.0);
}
#[test]
- fn flex_basis_overrides_measure() {
- let layout = stretch::node::Node::new(
+ fn width_overrides_measure() {
+ let mut stretch = stretch::node::Stretch::new();
+ let child = stretch.new_leaf(
stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(200.0),
- height: stretch::style::Dimension::Points(100.0),
- },
+ size: stretch::geometry::Size { width: stretch::style::Dimension::Points(50.0), ..Default::default() },
..Default::default()
},
- vec![
- &stretch::node::Node::new(
- stretch::style::Style {
- flex_basis: stretch::style::Dimension::Points(50.0),
- flex_grow: 1.0,
- ..Default::default()
- },
- vec![],
- ),
- &stretch::node::Node::new_leaf(
- stretch::style::Style {
- flex_basis: stretch::style::Dimension::Points(50.0),
- flex_grow: 1.0,
- ..Default::default()
- },
- Box::new(|constraint| {
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(100.0),
- height: constraint.height.or_else(100.0),
- })
- }),
- ),
- ],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[0].size.width, 100.0);
- assert_eq!(layout.children[0].size.height, 100.0);
- assert_eq!(layout.children[1].size.width, 100.0);
- assert_eq!(layout.children[1].size.height, 100.0);
+ Box::new(|constraint| {
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(100.0),
+ height: constraint.height.or_else(100.0),
+ })
+ }),
+ );
+ let node = stretch.new_node(stretch::style::Style { ..Default::default() }, vec![child]).unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child).unwrap().size.width, 50.0);
+ assert_eq!(stretch.layout(child).unwrap().size.height, 100.0);
}
#[test]
- fn stretch_overrides_measure() {
- let layout = stretch::node::Node::new(
+ fn height_overrides_measure() {
+ let mut stretch = stretch::node::Stretch::new();
+ let child = stretch.new_leaf(
stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(100.0),
- height: stretch::style::Dimension::Points(100.0),
- },
+ size: stretch::geometry::Size { height: stretch::style::Dimension::Points(50.0), ..Default::default() },
..Default::default()
},
- vec![&stretch::node::Node::new_leaf(
- stretch::style::Style { ..Default::default() },
- Box::new(|constraint| {
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(50.0),
- height: constraint.height.or_else(50.0),
- })
- }),
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[0].size.width, 50.0);
- assert_eq!(layout.children[0].size.height, 100.0);
+ Box::new(|constraint| {
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(100.0),
+ height: constraint.height.or_else(100.0),
+ })
+ }),
+ );
+ let node = stretch.new_node(stretch::style::Style { ..Default::default() }, vec![child]).unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child).unwrap().size.width, 100.0);
+ assert_eq!(stretch.layout(child).unwrap().size.height, 50.0);
}
#[test]
- fn measure_absolute_child() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(100.0),
- height: stretch::style::Dimension::Points(100.0),
+ fn flex_basis_overrides_measure() {
+ let mut stretch = stretch::node::Stretch::new();
+ let child0 = stretch
+ .new_node(
+ stretch::style::Style {
+ flex_basis: stretch::style::Dimension::Points(50.0),
+ flex_grow: 1.0,
+ ..Default::default()
},
+ vec![],
+ )
+ .unwrap();
+ let child1 = stretch.new_leaf(
+ stretch::style::Style {
+ flex_basis: stretch::style::Dimension::Points(50.0),
+ flex_grow: 1.0,
..Default::default()
},
- vec![&stretch::node::Node::new_leaf(
- stretch::style::Style { position_type: stretch::style::PositionType::Absolute, ..Default::default() },
- Box::new(|constraint| {
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(50.0),
- height: constraint.height.or_else(50.0),
- })
- }),
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[0].size.width, 50.0);
- assert_eq!(layout.children[0].size.height, 50.0);
+ Box::new(|constraint| {
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(100.0),
+ height: constraint.height.or_else(100.0),
+ })
+ }),
+ );
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(200.0),
+ height: stretch::style::Dimension::Points(100.0),
+ },
+ ..Default::default()
+ },
+ vec![child0, child1],
+ )
+ .unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child0).unwrap().size.width, 100.0);
+ assert_eq!(stretch.layout(child0).unwrap().size.height, 100.0);
+ assert_eq!(stretch.layout(child1).unwrap().size.width, 100.0);
+ assert_eq!(stretch.layout(child1).unwrap().size.height, 100.0);
+ }
+
+ #[test]
+ fn stretch_overrides_measure() {
+ let mut stretch = stretch::node::Stretch::new();
+ let child = stretch.new_leaf(
+ stretch::style::Style { ..Default::default() },
+ Box::new(|constraint| {
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(50.0),
+ height: constraint.height.or_else(50.0),
+ })
+ }),
+ );
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(100.0),
+ height: stretch::style::Dimension::Points(100.0),
+ },
+ ..Default::default()
+ },
+ vec![child],
+ )
+ .unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child).unwrap().size.width, 50.0);
+ assert_eq!(stretch.layout(child).unwrap().size.height, 100.0);
+ }
+
+ #[test]
+ fn measure_absolute_child() {
+ let mut stretch = stretch::node::Stretch::new();
+ let child = stretch.new_leaf(
+ stretch::style::Style { position_type: stretch::style::PositionType::Absolute, ..Default::default() },
+ Box::new(|constraint| {
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(50.0),
+ height: constraint.height.or_else(50.0),
+ })
+ }),
+ );
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(100.0),
+ height: stretch::style::Dimension::Points(100.0),
+ },
+ ..Default::default()
+ },
+ vec![child],
+ )
+ .unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child).unwrap().size.width, 50.0);
+ assert_eq!(stretch.layout(child).unwrap().size.height, 50.0);
}
#[test]
fn ignore_invalid_measure() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(100.0),
- height: stretch::style::Dimension::Points(100.0),
+ let mut stretch = stretch::node::Stretch::new();
+ let child = stretch.new_leaf(
+ stretch::style::Style { flex_grow: 1.0, ..Default::default() },
+ Box::new(|_| Ok(stretch::geometry::Size { width: 200.0, height: 200.0 })),
+ );
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(100.0),
+ height: stretch::style::Dimension::Points(100.0),
+ },
+ ..Default::default()
},
- ..Default::default()
- },
- vec![&stretch::node::Node::new_leaf(
- stretch::style::Style { flex_grow: 1.0, ..Default::default() },
- Box::new(|_| Ok(stretch::geometry::Size { width: 200.0, height: 200.0 })),
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
-
- assert_eq!(layout.children[0].size.width, 100.0);
- assert_eq!(layout.children[0].size.height, 100.0);
+ vec![child],
+ )
+ .unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.layout(child).unwrap().size.width, 100.0);
+ assert_eq!(stretch.layout(child).unwrap().size.height, 100.0);
}
#[test]
fn only_measure_once() {
+ let mut stretch = stretch::node::Stretch::new();
let mut num_measure = 0;
let num_measure_ptr = &mut num_measure as *mut i32;
- stretch::node::Node::new(
+ let grandchild = stretch.new_leaf(
stretch::style::Style { ..Default::default() },
- vec![&stretch::node::Node::new(
- stretch::style::Style { ..Default::default() },
- vec![&stretch::node::Node::new_leaf(
- stretch::style::Style { ..Default::default() },
- Box::new(move |constraint| {
- unsafe { (*num_measure_ptr) += 1 };
- Ok(stretch::geometry::Size {
- width: constraint.width.or_else(50.0),
- height: constraint.height.or_else(50.0),
- })
- }),
- )],
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined())
- .unwrap();
+ Box::new(move |constraint| {
+ unsafe { (*num_measure_ptr) += 1 };
+ Ok(stretch::geometry::Size {
+ width: constraint.width.or_else(50.0),
+ height: constraint.height.or_else(50.0),
+ })
+ }),
+ );
+
+ let child = stretch.new_node(stretch::style::Style { ..Default::default() }, vec![grandchild]).unwrap();
+
+ let node = stretch.new_node(stretch::style::Style { ..Default::default() }, vec![child]).unwrap();
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
assert_eq!(num_measure, 1);
}
#[test]
fn propagate_measure_error() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(100.0),
- height: stretch::style::Dimension::Points(100.0),
+ let mut stretch = stretch::node::Stretch::new();
+ let child = stretch
+ .new_leaf(stretch::style::Style { flex_grow: 1.0, ..Default::default() }, Box::new(|_| Err(Box::new(""))));
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(100.0),
+ height: stretch::style::Dimension::Points(100.0),
+ },
+ ..Default::default()
},
- ..Default::default()
- },
- vec![&stretch::node::Node::new_leaf(
- stretch::style::Style { flex_grow: 1.0, ..Default::default() },
- Box::new(|_| Err(Box::new(""))),
- )],
- )
- .compute_layout(stretch::geometry::Size::undefined());
-
- assert_eq!(layout.is_err(), true);
+ vec![child],
+ )
+ .unwrap();
+
+ assert_eq!(stretch.compute_layout(node, stretch::geometry::Size::undefined()).is_err(), true);
}
}
diff --git a/tests/node.rs b/tests/node.rs
index ea35cb990..689b5dc0c 100644
--- a/tests/node.rs
+++ b/tests/node.rs
@@ -1,136 +1,155 @@
#[cfg(test)]
mod node {
use stretch::geometry::*;
- use stretch::node::Node;
+ use stretch::node::Stretch;
use stretch::style::*;
#[test]
fn children() {
- let child1 = Node::new(Style::default(), vec![]);
- let child2 = Node::new(Style::default(), vec![]);
- let node = Node::new(Style::default(), vec![&child1, &child2]);
-
- assert_eq!(node.child_count(), 2);
- assert_eq!(node.children()[0], child1);
- assert_eq!(node.children()[1], child2);
+ let mut stretch = Stretch::new();
+ let child1 = stretch.new_node(Style::default(), vec![]).unwrap();
+ let child2 = stretch.new_node(Style::default(), vec![]).unwrap();
+ let node = stretch.new_node(Style::default(), vec![child1, child2]).unwrap();
+
+ assert_eq!(stretch.child_count(node).unwrap(), 2);
+ assert_eq!(stretch.children(node).unwrap()[0], child1);
+ assert_eq!(stretch.children(node).unwrap()[1], child2);
}
#[test]
fn set_measure() {
- let mut node = Node::new_leaf(Style::default(), Box::new(|_| Ok(Size { width: 200.0, height: 200.0 })));
- assert_eq!(node.compute_layout(Size::undefined()).unwrap().size.width, 200.0);
-
- node.set_measure(Some(Box::new(|_| Ok(Size { width: 100.0, height: 100.0 }))));
- assert_eq!(node.compute_layout(Size::undefined()).unwrap().size.width, 100.0);
+ let mut stretch = Stretch::new();
+ let node = stretch.new_leaf(Style::default(), Box::new(|_| Ok(Size { width: 200.0, height: 200.0 })));
+ stretch.compute_layout(node, Size::undefined()).unwrap();
+ assert_eq!(stretch.layout(node).unwrap().size.width, 200.0);
+
+ stretch.set_measure(node, Some(Box::new(|_| Ok(Size { width: 100.0, height: 100.0 })))).unwrap();
+ stretch.compute_layout(node, Size::undefined()).unwrap();
+ assert_eq!(stretch.layout(node).unwrap().size.width, 100.0);
}
#[test]
fn add_child() {
- let mut node = Node::new(Style::default(), vec![]);
- assert_eq!(node.child_count(), 0);
+ let mut stretch = Stretch::new();
+ let node = stretch.new_node(Style::default(), vec![]).unwrap();
+ assert_eq!(stretch.child_count(node).unwrap(), 0);
- node.add_child(&Node::new(Style::default(), vec![]));
- assert_eq!(node.child_count(), 1);
+ let child1 = stretch.new_node(Style::default(), vec![]).unwrap();
+ stretch.add_child(node, child1).unwrap();
+ assert_eq!(stretch.child_count(node).unwrap(), 1);
- node.add_child(&Node::new(Style::default(), vec![]));
- assert_eq!(node.child_count(), 2);
+ let child2 = stretch.new_node(Style::default(), vec![]).unwrap();
+ stretch.add_child(node, child2);
+ assert_eq!(stretch.child_count(node).unwrap(), 2);
}
#[test]
fn remove_child() {
- let child1 = Node::new(Style::default(), vec![]);
- let child2 = Node::new(Style::default(), vec![]);
+ let mut stretch = Stretch::new();
+
+ let child1 = stretch.new_node(Style::default(), vec![]).unwrap();
+ let child2 = stretch.new_node(Style::default(), vec![]).unwrap();
- let mut node = Node::new(Style::default(), vec![&child1, &child2]);
- assert_eq!(node.child_count(), 2);
+ let node = stretch.new_node(Style::default(), vec![child1, child2]).unwrap();
+ assert_eq!(stretch.child_count(node).unwrap(), 2);
- node.remove_child(&child1);
- assert_eq!(node.child_count(), 1);
- assert_eq!(node.children()[0], child2);
+ stretch.remove_child(node, child1);
+ assert_eq!(stretch.child_count(node).unwrap(), 1);
+ assert_eq!(stretch.children(node).unwrap()[0], child2);
- node.remove_child(&child2);
- assert_eq!(node.child_count(), 0);
+ stretch.remove_child(node, child2);
+ assert_eq!(stretch.child_count(node).unwrap(), 0);
}
#[test]
fn remove_child_at_index() {
- let child1 = Node::new(Style::default(), vec![]);
- let child2 = Node::new(Style::default(), vec![]);
+ let mut stretch = Stretch::new();
- let mut node = Node::new(Style::default(), vec![&child1, &child2]);
- assert_eq!(node.child_count(), 2);
+ let child1 = stretch.new_node(Style::default(), vec![]).unwrap();
+ let child2 = stretch.new_node(Style::default(), vec![]).unwrap();
- node.remove_child_at_index(0);
- assert_eq!(node.child_count(), 1);
- assert_eq!(node.children()[0], child2);
+ let node = stretch.new_node(Style::default(), vec![child1, child2]).unwrap();
+ assert_eq!(stretch.child_count(node).unwrap(), 2);
- node.remove_child_at_index(0);
- assert_eq!(node.child_count(), 0);
+ stretch.remove_child_at_index(node, 0).unwrap();
+ assert_eq!(stretch.child_count(node).unwrap(), 1);
+ assert_eq!(stretch.children(node).unwrap()[0], child2);
+
+ stretch.remove_child_at_index(node, 0).unwrap();
+ assert_eq!(stretch.child_count(node).unwrap(), 0);
}
#[test]
fn replace_child_at_index() {
- let child1 = Node::new(Style::default(), vec![]);
- let child2 = Node::new(Style::default(), vec![]);
+ let mut stretch = Stretch::new();
+
+ let child1 = stretch.new_node(Style::default(), vec![]).unwrap();
+ let child2 = stretch.new_node(Style::default(), vec![]).unwrap();
- let mut node = Node::new(Style::default(), vec![&child1]);
- assert_eq!(node.child_count(), 1);
- assert_eq!(node.children()[0], child1);
+ let node = stretch.new_node(Style::default(), vec![child1]).unwrap();
+ assert_eq!(stretch.child_count(node).unwrap(), 1);
+ assert_eq!(stretch.children(node).unwrap()[0], child1);
- node.replace_child_at_index(0, &child2);
- assert_eq!(node.child_count(), 1);
- assert_eq!(node.children()[0], child2);
+ stretch.replace_child_at_index(node, 0, child2).unwrap();
+ assert_eq!(stretch.child_count(node).unwrap(), 1);
+ assert_eq!(stretch.children(node).unwrap()[0], child2);
}
#[test]
fn set_children() {
- let child1 = Node::new(Style::default(), vec![]);
- let child2 = Node::new(Style::default(), vec![]);
- let mut node = Node::new(Style::default(), vec![&child1, &child2]);
+ let mut stretch = Stretch::new();
+
+ let child1 = stretch.new_node(Style::default(), vec![]).unwrap();
+ let child2 = stretch.new_node(Style::default(), vec![]).unwrap();
+ let node = stretch.new_node(Style::default(), vec![child1, child2]).unwrap();
- assert_eq!(node.child_count(), 2);
- assert_eq!(node.children()[0], child1);
- assert_eq!(node.children()[1], child2);
+ assert_eq!(stretch.child_count(node).unwrap(), 2);
+ assert_eq!(stretch.children(node).unwrap()[0], child1);
+ assert_eq!(stretch.children(node).unwrap()[1], child2);
- let child3 = Node::new(Style::default(), vec![]);
- let child4 = Node::new(Style::default(), vec![]);
- node.set_children(vec![&child3, &child4]);
+ let child3 = stretch.new_node(Style::default(), vec![]).unwrap();
+ let child4 = stretch.new_node(Style::default(), vec![]).unwrap();
+ stretch.set_children(node, vec![child3, child4]);
- assert_eq!(node.child_count(), 2);
- assert_eq!(node.children()[0], child3);
- assert_eq!(node.children()[1], child4);
+ assert_eq!(stretch.child_count(node).unwrap(), 2);
+ assert_eq!(stretch.children(node).unwrap()[0], child3);
+ assert_eq!(stretch.children(node).unwrap()[1], child4);
}
#[test]
fn set_style() {
- let mut node = Node::new(Style::default(), vec![]);
- assert_eq!(node.style().display, Display::Flex);
+ let mut stretch = Stretch::new();
- node.set_style(Style { display: Display::None, ..Style::default() });
- assert_eq!(node.style().display, Display::None);
+ let node = stretch.new_node(Style::default(), vec![]).unwrap();
+ assert_eq!(stretch.style(node).unwrap().display, Display::Flex);
+
+ stretch.set_style(node, Style { display: Display::None, ..Style::default() }).unwrap();
+ assert_eq!(stretch.style(node).unwrap().display, Display::None);
}
#[test]
fn mark_dirty() {
- let mut child1 = Node::new(Style::default(), vec![]);
- let child2 = Node::new(Style::default(), vec![]);
- let mut node = Node::new(Style::default(), vec![&child1, &child2]);
-
- node.compute_layout(stretch::geometry::Size::undefined()).unwrap();
-
- assert_eq!(child1.dirty(), false);
- assert_eq!(child2.dirty(), false);
- assert_eq!(node.dirty(), false);
-
- node.mark_dirty();
- assert_eq!(child1.dirty(), false);
- assert_eq!(child2.dirty(), false);
- assert_eq!(node.dirty(), true);
-
- node.compute_layout(stretch::geometry::Size::undefined()).unwrap();
- child1.mark_dirty();
- assert_eq!(child1.dirty(), true);
- assert_eq!(child2.dirty(), false);
- assert_eq!(node.dirty(), true);
+ let mut stretch = Stretch::new();
+
+ let child1 = stretch.new_node(Style::default(), vec![]).unwrap();
+ let child2 = stretch.new_node(Style::default(), vec![]).unwrap();
+ let node = stretch.new_node(Style::default(), vec![child1, child2]).unwrap();
+
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+
+ assert_eq!(stretch.dirty(child1).unwrap(), false);
+ assert_eq!(stretch.dirty(child2).unwrap(), false);
+ assert_eq!(stretch.dirty(node).unwrap(), false);
+
+ stretch.mark_dirty(node);
+ assert_eq!(stretch.dirty(child1).unwrap(), false);
+ assert_eq!(stretch.dirty(child2).unwrap(), false);
+ assert_eq!(stretch.dirty(node).unwrap(), true);
+
+ stretch.compute_layout(node, stretch::geometry::Size::undefined()).unwrap();
+ stretch.mark_dirty(child1);
+ assert_eq!(stretch.dirty(child1).unwrap(), true);
+ assert_eq!(stretch.dirty(child2).unwrap(), false);
+ assert_eq!(stretch.dirty(node).unwrap(), true);
}
}
diff --git a/tests/root_constraints.rs b/tests/root_constraints.rs
index d13a5ed49..737ed6044 100644
--- a/tests/root_constraints.rs
+++ b/tests/root_constraints.rs
@@ -4,18 +4,27 @@ mod root_constraints {
#[test]
fn root_with_percentage_size() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Percent(1.0),
- height: stretch::style::Dimension::Percent(1.0),
+ let mut stretch = stretch::node::Stretch::new();
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Percent(1.0),
+ height: stretch::style::Dimension::Percent(1.0),
+ },
+ ..Default::default()
},
- ..Default::default()
- },
- vec![],
- )
- .compute_layout(stretch::geometry::Size { width: Number::Defined(100.0), height: Number::Defined(200.0) })
- .unwrap();
+ vec![],
+ )
+ .unwrap();
+
+ stretch
+ .compute_layout(
+ node,
+ stretch::geometry::Size { width: Number::Defined(100.0), height: Number::Defined(200.0) },
+ )
+ .unwrap();
+ let layout = stretch.layout(node).unwrap();
assert_eq!(layout.size.width, 100.0);
assert_eq!(layout.size.height, 200.0);
@@ -23,9 +32,16 @@ mod root_constraints {
#[test]
fn root_with_no_size() {
- let layout = stretch::node::Node::new(stretch::style::Style { ..Default::default() }, vec![])
- .compute_layout(stretch::geometry::Size { width: Number::Defined(100.0), height: Number::Defined(100.0) })
+ let mut stretch = stretch::node::Stretch::new();
+ let node = stretch.new_node(stretch::style::Style { ..Default::default() }, vec![]).unwrap();
+
+ stretch
+ .compute_layout(
+ node,
+ stretch::geometry::Size { width: Number::Defined(100.0), height: Number::Defined(100.0) },
+ )
.unwrap();
+ let layout = stretch.layout(node).unwrap();
assert_eq!(layout.size.width, 0.0);
assert_eq!(layout.size.height, 0.0);
@@ -33,18 +49,27 @@ mod root_constraints {
#[test]
fn root_with_larger_size() {
- let layout = stretch::node::Node::new(
- stretch::style::Style {
- size: stretch::geometry::Size {
- width: stretch::style::Dimension::Points(200.0),
- height: stretch::style::Dimension::Points(200.0),
+ let mut stretch = stretch::node::Stretch::new();
+ let node = stretch
+ .new_node(
+ stretch::style::Style {
+ size: stretch::geometry::Size {
+ width: stretch::style::Dimension::Points(200.0),
+ height: stretch::style::Dimension::Points(200.0),
+ },
+ ..Default::default()
},
- ..Default::default()
- },
- vec![],
- )
- .compute_layout(stretch::geometry::Size { width: Number::Defined(100.0), height: Number::Defined(100.0) })
- .unwrap();
+ vec![],
+ )
+ .unwrap();
+
+ stretch
+ .compute_layout(
+ node,
+ stretch::geometry::Size { width: Number::Defined(100.0), height: Number::Defined(100.0) },
+ )
+ .unwrap();
+ let layout = stretch.layout(node).unwrap();
assert_eq!(layout.size.width, 200.0);
assert_eq!(layout.size.height, 200.0);