+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/border_overrides_min_size.html b/test_fixtures/border_overrides_min_size.html
new file mode 100644
index 000000000..c46010bad
--- /dev/null
+++ b/test_fixtures/border_overrides_min_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/border_overrides_size.html b/test_fixtures/border_overrides_size.html
new file mode 100644
index 000000000..4025c8ab3
--- /dev/null
+++ b/test_fixtures/border_overrides_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/generated/border_overrides_max_size.rs b/tests/generated/border_overrides_max_size.rs
new file mode 100644
index 000000000..18b1e8c91
--- /dev/null
+++ b/tests/generated/border_overrides_max_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn border_overrides_max_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ max_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(5f32),
+ height: taffy::style::Dimension::Points(5f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/border_overrides_min_size.rs b/tests/generated/border_overrides_min_size.rs
new file mode 100644
index 000000000..de00911e3
--- /dev/null
+++ b/tests/generated/border_overrides_min_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn border_overrides_min_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ min_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(0f32),
+ height: taffy::style::Dimension::Points(0f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/border_overrides_size.rs b/tests/generated/border_overrides_size.rs
new file mode 100644
index 000000000..c4c4d0f48
--- /dev/null
+++ b/tests/generated/border_overrides_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn border_overrides_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(5f32),
+ height: taffy::style::Dimension::Points(5f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/mod.rs b/tests/generated/mod.rs
index 8a7799d86..f44e4ef10 100644
--- a/tests/generated/mod.rs
+++ b/tests/generated/mod.rs
@@ -204,6 +204,9 @@ mod border_container_match_child;
mod border_flex_child;
mod border_no_child;
mod border_no_size;
+mod border_overrides_max_size;
+mod border_overrides_min_size;
+mod border_overrides_size;
mod border_stretch_child;
mod child_min_max_width_flexing;
mod child_with_padding_align_end;
From f6e4202704277c98a189539333ee4254c63a1f90 Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 16:29:17 +0000
Subject: [PATCH 02/22] Add failing tests for padding flooring node size
---
test_fixtures/padding_overrides_max_size.html | 15 +++++++++
test_fixtures/padding_overrides_min_size.html | 15 +++++++++
test_fixtures/padding_overrides_size.html | 15 +++++++++
tests/generated/mod.rs | 3 ++
tests/generated/padding_overrides_max_size.rs | 31 +++++++++++++++++++
tests/generated/padding_overrides_min_size.rs | 31 +++++++++++++++++++
tests/generated/padding_overrides_size.rs | 31 +++++++++++++++++++
7 files changed, 141 insertions(+)
create mode 100644 test_fixtures/padding_overrides_max_size.html
create mode 100644 test_fixtures/padding_overrides_min_size.html
create mode 100644 test_fixtures/padding_overrides_size.html
create mode 100644 tests/generated/padding_overrides_max_size.rs
create mode 100644 tests/generated/padding_overrides_min_size.rs
create mode 100644 tests/generated/padding_overrides_size.rs
diff --git a/test_fixtures/padding_overrides_max_size.html b/test_fixtures/padding_overrides_max_size.html
new file mode 100644
index 000000000..4652fc4db
--- /dev/null
+++ b/test_fixtures/padding_overrides_max_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/padding_overrides_min_size.html b/test_fixtures/padding_overrides_min_size.html
new file mode 100644
index 000000000..f570321c8
--- /dev/null
+++ b/test_fixtures/padding_overrides_min_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/padding_overrides_size.html b/test_fixtures/padding_overrides_size.html
new file mode 100644
index 000000000..4824b8b1a
--- /dev/null
+++ b/test_fixtures/padding_overrides_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/generated/mod.rs b/tests/generated/mod.rs
index f44e4ef10..f917621c7 100644
--- a/tests/generated/mod.rs
+++ b/tests/generated/mod.rs
@@ -828,6 +828,9 @@ mod padding_container_match_child;
mod padding_flex_child;
mod padding_no_child;
mod padding_no_size;
+mod padding_overrides_max_size;
+mod padding_overrides_min_size;
+mod padding_overrides_size;
mod padding_stretch_child;
mod parent_wrap_child_size_overflowing_parent;
mod percent_absolute_position;
diff --git a/tests/generated/padding_overrides_max_size.rs b/tests/generated/padding_overrides_max_size.rs
new file mode 100644
index 000000000..cf314361b
--- /dev/null
+++ b/tests/generated/padding_overrides_max_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn padding_overrides_max_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ max_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(5f32),
+ height: taffy::style::Dimension::Points(5f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/padding_overrides_min_size.rs b/tests/generated/padding_overrides_min_size.rs
new file mode 100644
index 000000000..d82793a76
--- /dev/null
+++ b/tests/generated/padding_overrides_min_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn padding_overrides_min_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ min_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(0f32),
+ height: taffy::style::Dimension::Points(0f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/padding_overrides_size.rs b/tests/generated/padding_overrides_size.rs
new file mode 100644
index 000000000..3ccf6c2d7
--- /dev/null
+++ b/tests/generated/padding_overrides_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn padding_overrides_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(5f32),
+ height: taffy::style::Dimension::Points(5f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
From 58ca3222baad3b5710af5476960caa6b5da0af5f Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 19:58:43 +0000
Subject: [PATCH 03/22] Fix divide by zero in main size determination
---
src/compute/flexbox.rs | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/src/compute/flexbox.rs b/src/compute/flexbox.rs
index 13458ea4d..ba88eb606 100644
--- a/src/compute/flexbox.rs
+++ b/src/compute/flexbox.rs
@@ -902,8 +902,7 @@ fn determine_container_main_size(
if diff > 0.0 {
diff / f32_max(1.0, item.flex_grow)
} else if diff < 0.0 {
- let scaled_shrink_factor = f32_max(1.0, item.flex_shrink) * item.inner_flex_basis;
- // let scaled_shrink_factor - f32_max(1.0, item.flex_shrink * item.inner_flex_basis);
+ let scaled_shrink_factor = f32_max(1.0, item.flex_shrink * item.inner_flex_basis);
diff / scaled_shrink_factor
} else {
// We are assuming that diff is 0.0 here and that we haven't accidentally introduced a NaN
From fbf950e8ade5f0ad037d9770e514bfbf82778598 Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 21:57:29 +0000
Subject: [PATCH 04/22] Add seperate leaf and flexbox tests for padding/border
flooring node size
---
test_fixtures/border_overrides_max_size.html | 4 ++-
test_fixtures/border_overrides_min_size.html | 4 ++-
test_fixtures/border_overrides_size.html | 4 ++-
.../leaf_border_overrides_max_size.html | 15 +++++++++
.../leaf_border_overrides_min_size.html | 15 +++++++++
test_fixtures/leaf_border_overrides_size.html | 15 +++++++++
.../leaf_padding_overrides_max_size.html | 15 +++++++++
.../leaf_padding_overrides_min_size.html | 15 +++++++++
.../leaf_padding_overrides_size.html | 15 +++++++++
test_fixtures/padding_overrides_max_size.html | 4 ++-
test_fixtures/padding_overrides_min_size.html | 4 ++-
test_fixtures/padding_overrides_size.html | 4 ++-
tests/border_and_padding.rs | 4 +++
tests/generated/border_overrides_max_size.rs | 8 ++++-
tests/generated/border_overrides_min_size.rs | 8 ++++-
tests/generated/border_overrides_size.rs | 8 ++++-
.../leaf_border_overrides_max_size.rs | 31 +++++++++++++++++++
.../leaf_border_overrides_min_size.rs | 31 +++++++++++++++++++
tests/generated/leaf_border_overrides_size.rs | 31 +++++++++++++++++++
.../leaf_padding_overrides_max_size.rs | 31 +++++++++++++++++++
.../leaf_padding_overrides_min_size.rs | 31 +++++++++++++++++++
.../generated/leaf_padding_overrides_size.rs | 31 +++++++++++++++++++
tests/generated/mod.rs | 6 ++++
tests/generated/padding_overrides_max_size.rs | 8 ++++-
tests/generated/padding_overrides_min_size.rs | 8 ++++-
tests/generated/padding_overrides_size.rs | 8 ++++-
26 files changed, 346 insertions(+), 12 deletions(-)
create mode 100644 test_fixtures/leaf_border_overrides_max_size.html
create mode 100644 test_fixtures/leaf_border_overrides_min_size.html
create mode 100644 test_fixtures/leaf_border_overrides_size.html
create mode 100644 test_fixtures/leaf_padding_overrides_max_size.html
create mode 100644 test_fixtures/leaf_padding_overrides_min_size.html
create mode 100644 test_fixtures/leaf_padding_overrides_size.html
create mode 100644 tests/generated/leaf_border_overrides_max_size.rs
create mode 100644 tests/generated/leaf_border_overrides_min_size.rs
create mode 100644 tests/generated/leaf_border_overrides_size.rs
create mode 100644 tests/generated/leaf_padding_overrides_max_size.rs
create mode 100644 tests/generated/leaf_padding_overrides_min_size.rs
create mode 100644 tests/generated/leaf_padding_overrides_size.rs
diff --git a/test_fixtures/border_overrides_max_size.html b/test_fixtures/border_overrides_max_size.html
index dadfac53c..92769ac00 100644
--- a/test_fixtures/border_overrides_max_size.html
+++ b/test_fixtures/border_overrides_max_size.html
@@ -9,7 +9,9 @@
-
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/border_overrides_min_size.html b/test_fixtures/border_overrides_min_size.html
index c46010bad..817e820f4 100644
--- a/test_fixtures/border_overrides_min_size.html
+++ b/test_fixtures/border_overrides_min_size.html
@@ -9,7 +9,9 @@
-
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/border_overrides_size.html b/test_fixtures/border_overrides_size.html
index 4025c8ab3..f0ac72df8 100644
--- a/test_fixtures/border_overrides_size.html
+++ b/test_fixtures/border_overrides_size.html
@@ -9,7 +9,9 @@
-
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/leaf_border_overrides_max_size.html b/test_fixtures/leaf_border_overrides_max_size.html
new file mode 100644
index 000000000..dadfac53c
--- /dev/null
+++ b/test_fixtures/leaf_border_overrides_max_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/leaf_border_overrides_min_size.html b/test_fixtures/leaf_border_overrides_min_size.html
new file mode 100644
index 000000000..c46010bad
--- /dev/null
+++ b/test_fixtures/leaf_border_overrides_min_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/leaf_border_overrides_size.html b/test_fixtures/leaf_border_overrides_size.html
new file mode 100644
index 000000000..4025c8ab3
--- /dev/null
+++ b/test_fixtures/leaf_border_overrides_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/leaf_padding_overrides_max_size.html b/test_fixtures/leaf_padding_overrides_max_size.html
new file mode 100644
index 000000000..4652fc4db
--- /dev/null
+++ b/test_fixtures/leaf_padding_overrides_max_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/leaf_padding_overrides_min_size.html b/test_fixtures/leaf_padding_overrides_min_size.html
new file mode 100644
index 000000000..f570321c8
--- /dev/null
+++ b/test_fixtures/leaf_padding_overrides_min_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/leaf_padding_overrides_size.html b/test_fixtures/leaf_padding_overrides_size.html
new file mode 100644
index 000000000..4824b8b1a
--- /dev/null
+++ b/test_fixtures/leaf_padding_overrides_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/padding_overrides_max_size.html b/test_fixtures/padding_overrides_max_size.html
index 4652fc4db..57c6d3cbb 100644
--- a/test_fixtures/padding_overrides_max_size.html
+++ b/test_fixtures/padding_overrides_max_size.html
@@ -9,7 +9,9 @@
-
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/padding_overrides_min_size.html b/test_fixtures/padding_overrides_min_size.html
index f570321c8..286832e13 100644
--- a/test_fixtures/padding_overrides_min_size.html
+++ b/test_fixtures/padding_overrides_min_size.html
@@ -9,7 +9,9 @@
-
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/padding_overrides_size.html b/test_fixtures/padding_overrides_size.html
index 4824b8b1a..e5779fbf3 100644
--- a/test_fixtures/padding_overrides_size.html
+++ b/test_fixtures/padding_overrides_size.html
@@ -9,7 +9,9 @@
-
+
+
+
\ No newline at end of file
diff --git a/tests/border_and_padding.rs b/tests/border_and_padding.rs
index 26cfd1a1f..17a51914f 100644
--- a/tests/border_and_padding.rs
+++ b/tests/border_and_padding.rs
@@ -6,6 +6,7 @@ fn arr_to_rect(items: [T; 4]) -> Rect {
}
#[test]
+#[ignore]
fn border_on_a_single_axis_doesnt_increase_size() {
for i in 0..4 {
let mut taffy = Taffy::new();
@@ -33,6 +34,7 @@ fn border_on_a_single_axis_doesnt_increase_size() {
}
#[test]
+#[ignore]
fn padding_on_a_single_axis_doesnt_increase_size() {
for i in 0..4 {
let mut taffy = Taffy::new();
@@ -60,6 +62,7 @@ fn padding_on_a_single_axis_doesnt_increase_size() {
}
#[test]
+#[ignore]
fn border_and_padding_on_a_single_axis_doesnt_increase_size() {
for i in 0..4 {
let mut taffy = Taffy::new();
@@ -82,6 +85,7 @@ fn border_and_padding_on_a_single_axis_doesnt_increase_size() {
}
#[test]
+#[ignore]
fn vertical_border_and_padding_percentage_values_use_available_space_correctly() {
let mut taffy = Taffy::new();
diff --git a/tests/generated/border_overrides_max_size.rs b/tests/generated/border_overrides_max_size.rs
index 18b1e8c91..eb0c1aa00 100644
--- a/tests/generated/border_overrides_max_size.rs
+++ b/tests/generated/border_overrides_max_size.rs
@@ -4,7 +4,7 @@ fn border_overrides_max_size() {
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
let mut taffy = taffy::Taffy::new();
- let node = taffy
+ let node0 = taffy
.new_leaf(taffy::style::Style {
max_size: taffy::geometry::Size {
width: taffy::style::Dimension::Points(5f32),
@@ -19,6 +19,7 @@ fn border_overrides_max_size() {
..Default::default()
})
.unwrap();
+ let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
println!("\nComputed tree:");
taffy::debug::print_tree(&taffy, node);
@@ -28,4 +29,9 @@ fn border_overrides_max_size() {
assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
}
diff --git a/tests/generated/border_overrides_min_size.rs b/tests/generated/border_overrides_min_size.rs
index de00911e3..ce5cb315a 100644
--- a/tests/generated/border_overrides_min_size.rs
+++ b/tests/generated/border_overrides_min_size.rs
@@ -4,7 +4,7 @@ fn border_overrides_min_size() {
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
let mut taffy = taffy::Taffy::new();
- let node = taffy
+ let node0 = taffy
.new_leaf(taffy::style::Style {
min_size: taffy::geometry::Size {
width: taffy::style::Dimension::Points(0f32),
@@ -19,6 +19,7 @@ fn border_overrides_min_size() {
..Default::default()
})
.unwrap();
+ let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
println!("\nComputed tree:");
taffy::debug::print_tree(&taffy, node);
@@ -28,4 +29,9 @@ fn border_overrides_min_size() {
assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
}
diff --git a/tests/generated/border_overrides_size.rs b/tests/generated/border_overrides_size.rs
index c4c4d0f48..55aae4e12 100644
--- a/tests/generated/border_overrides_size.rs
+++ b/tests/generated/border_overrides_size.rs
@@ -4,7 +4,7 @@ fn border_overrides_size() {
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
let mut taffy = taffy::Taffy::new();
- let node = taffy
+ let node0 = taffy
.new_leaf(taffy::style::Style {
size: taffy::geometry::Size {
width: taffy::style::Dimension::Points(5f32),
@@ -19,6 +19,7 @@ fn border_overrides_size() {
..Default::default()
})
.unwrap();
+ let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
println!("\nComputed tree:");
taffy::debug::print_tree(&taffy, node);
@@ -28,4 +29,9 @@ fn border_overrides_size() {
assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
}
diff --git a/tests/generated/leaf_border_overrides_max_size.rs b/tests/generated/leaf_border_overrides_max_size.rs
new file mode 100644
index 000000000..e914ef118
--- /dev/null
+++ b/tests/generated/leaf_border_overrides_max_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn leaf_border_overrides_max_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ max_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(5f32),
+ height: taffy::style::Dimension::Points(5f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/leaf_border_overrides_min_size.rs b/tests/generated/leaf_border_overrides_min_size.rs
new file mode 100644
index 000000000..2681bf73d
--- /dev/null
+++ b/tests/generated/leaf_border_overrides_min_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn leaf_border_overrides_min_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ min_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(0f32),
+ height: taffy::style::Dimension::Points(0f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/leaf_border_overrides_size.rs b/tests/generated/leaf_border_overrides_size.rs
new file mode 100644
index 000000000..1f99cab4f
--- /dev/null
+++ b/tests/generated/leaf_border_overrides_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn leaf_border_overrides_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(5f32),
+ height: taffy::style::Dimension::Points(5f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/leaf_padding_overrides_max_size.rs b/tests/generated/leaf_padding_overrides_max_size.rs
new file mode 100644
index 000000000..43ae81573
--- /dev/null
+++ b/tests/generated/leaf_padding_overrides_max_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn leaf_padding_overrides_max_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ max_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(5f32),
+ height: taffy::style::Dimension::Points(5f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/leaf_padding_overrides_min_size.rs b/tests/generated/leaf_padding_overrides_min_size.rs
new file mode 100644
index 000000000..8d38d4898
--- /dev/null
+++ b/tests/generated/leaf_padding_overrides_min_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn leaf_padding_overrides_min_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ min_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(0f32),
+ height: taffy::style::Dimension::Points(0f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/leaf_padding_overrides_size.rs b/tests/generated/leaf_padding_overrides_size.rs
new file mode 100644
index 000000000..51164cd95
--- /dev/null
+++ b/tests/generated/leaf_padding_overrides_size.rs
@@ -0,0 +1,31 @@
+#[test]
+fn leaf_padding_overrides_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(5f32),
+ height: taffy::style::Dimension::Points(5f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(10f32),
+ right: taffy::style::LengthPercentage::Points(10f32),
+ top: taffy::style::LengthPercentage::Points(10f32),
+ bottom: taffy::style::LengthPercentage::Points(10f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/mod.rs b/tests/generated/mod.rs
index f917621c7..4827c16e6 100644
--- a/tests/generated/mod.rs
+++ b/tests/generated/mod.rs
@@ -753,6 +753,12 @@ mod justify_content_row_min_width_and_margin;
mod justify_content_row_space_around;
mod justify_content_row_space_between;
mod justify_content_row_space_evenly;
+mod leaf_border_overrides_max_size;
+mod leaf_border_overrides_min_size;
+mod leaf_border_overrides_size;
+mod leaf_padding_overrides_max_size;
+mod leaf_padding_overrides_min_size;
+mod leaf_padding_overrides_size;
mod margin_and_flex_column;
mod margin_and_flex_row;
mod margin_and_stretch_column;
diff --git a/tests/generated/padding_overrides_max_size.rs b/tests/generated/padding_overrides_max_size.rs
index cf314361b..16a38166d 100644
--- a/tests/generated/padding_overrides_max_size.rs
+++ b/tests/generated/padding_overrides_max_size.rs
@@ -4,7 +4,7 @@ fn padding_overrides_max_size() {
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
let mut taffy = taffy::Taffy::new();
- let node = taffy
+ let node0 = taffy
.new_leaf(taffy::style::Style {
max_size: taffy::geometry::Size {
width: taffy::style::Dimension::Points(5f32),
@@ -19,6 +19,7 @@ fn padding_overrides_max_size() {
..Default::default()
})
.unwrap();
+ let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
println!("\nComputed tree:");
taffy::debug::print_tree(&taffy, node);
@@ -28,4 +29,9 @@ fn padding_overrides_max_size() {
assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
}
diff --git a/tests/generated/padding_overrides_min_size.rs b/tests/generated/padding_overrides_min_size.rs
index d82793a76..5dea4e063 100644
--- a/tests/generated/padding_overrides_min_size.rs
+++ b/tests/generated/padding_overrides_min_size.rs
@@ -4,7 +4,7 @@ fn padding_overrides_min_size() {
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
let mut taffy = taffy::Taffy::new();
- let node = taffy
+ let node0 = taffy
.new_leaf(taffy::style::Style {
min_size: taffy::geometry::Size {
width: taffy::style::Dimension::Points(0f32),
@@ -19,6 +19,7 @@ fn padding_overrides_min_size() {
..Default::default()
})
.unwrap();
+ let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
println!("\nComputed tree:");
taffy::debug::print_tree(&taffy, node);
@@ -28,4 +29,9 @@ fn padding_overrides_min_size() {
assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
}
diff --git a/tests/generated/padding_overrides_size.rs b/tests/generated/padding_overrides_size.rs
index 3ccf6c2d7..f076ffbe5 100644
--- a/tests/generated/padding_overrides_size.rs
+++ b/tests/generated/padding_overrides_size.rs
@@ -4,7 +4,7 @@ fn padding_overrides_size() {
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
let mut taffy = taffy::Taffy::new();
- let node = taffy
+ let node0 = taffy
.new_leaf(taffy::style::Style {
size: taffy::geometry::Size {
width: taffy::style::Dimension::Points(5f32),
@@ -19,6 +19,7 @@ fn padding_overrides_size() {
..Default::default()
})
.unwrap();
+ let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
println!("\nComputed tree:");
taffy::debug::print_tree(&taffy, node);
@@ -28,4 +29,9 @@ fn padding_overrides_size() {
assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
+ assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
}
From bae7a8e8cfce6415685c4d1c41e55133545f73b6 Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 21:57:57 +0000
Subject: [PATCH 05/22] Fix padding/border flooring leaf node size
---
src/compute/leaf.rs | 30 ++++++++++++++++++++----------
1 file changed, 20 insertions(+), 10 deletions(-)
diff --git a/src/compute/leaf.rs b/src/compute/leaf.rs
index 2c347a64d..5d0a59e8f 100644
--- a/src/compute/leaf.rs
+++ b/src/compute/leaf.rs
@@ -72,6 +72,12 @@ pub(crate) fn compute(
}
};
+ // Note: both horizontal and vertical percentage padding/borders are resolved against the container's inline size (i.e. width).
+ // This is not a bug, but is how CSS is specified (see: https://developer.mozilla.org/en-US/docs/Web/CSS/padding#values)
+ let padding = style.padding.resolve_or_zero(parent_size.width);
+ let border = style.border.resolve_or_zero(parent_size.width);
+ let padding_border = padding + border;
+
#[cfg(feature = "debug")]
NODE_LOGGER.log("LEAF");
#[cfg(feature = "debug")]
@@ -83,7 +89,9 @@ pub(crate) fn compute(
// Return early if both width and height are known
if let Size { width: Some(width), height: Some(height) } = node_size {
- let size = Size { width, height }.maybe_clamp(node_min_size, node_max_size);
+ let size = Size { width, height }
+ .maybe_clamp(node_min_size, node_max_size)
+ .maybe_max(padding_border.sum_axes().map(Some));
return SizeAndBaselines { size, first_baselines: Point::NONE };
};
@@ -111,25 +119,27 @@ pub(crate) fn compute(
};
let size = node_size.unwrap_or(measured_size).maybe_clamp(node_min_size, node_max_size);
+ let size = size.maybe_max(padding_border.sum_axes().map(Some));
+ // let size = match sizing_mode {
+ // SizingMode::ContentSize => size,
+ // SizingMode::InherentSize => size.maybe_max(padding_border.sum_axes().map(Some)),
+ // };
return SizeAndBaselines { size, first_baselines: Point::NONE };
}
- // Note: both horizontal and vertical percentage padding/borders are resolved against the container's inline size (i.e. width).
- // This is not a bug, but is how CSS is specified (see: https://developer.mozilla.org/en-US/docs/Web/CSS/padding#values)
- let padding = style.padding.resolve_or_zero(parent_size.width);
- let border = style.border.resolve_or_zero(parent_size.width);
-
let size = Size {
width: node_size
.width
// .unwrap_or(0.0) + padding.horizontal_axis_sum() + border.horizontal_axis_sum(), // content-box
- .unwrap_or(0.0 + padding.horizontal_axis_sum() + border.horizontal_axis_sum()) // border-box
- .maybe_clamp(node_min_size.width, node_max_size.width),
+ .unwrap_or(0.0) // border-box
+ .maybe_clamp(node_min_size.width, node_max_size.width)
+ .maybe_max(padding_border.horizontal_axis_sum().into()),
height: node_size
.height
// .unwrap_or(0.0) + padding.vertical_axis_sum() + border.vertical_axis_sum(), // content-box
- .unwrap_or(0.0 + padding.vertical_axis_sum() + border.vertical_axis_sum()) // border-box
- .maybe_clamp(node_min_size.height, node_max_size.height),
+ .unwrap_or(0.0) // border-box
+ .maybe_clamp(node_min_size.height, node_max_size.height)
+ .maybe_max(padding_border.vertical_axis_sum().into()),
};
SizeAndBaselines { size, first_baselines: Point::NONE }
}
From 86ba2ffa6a0566fe04e83d5ceab798ba272888f0 Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 22:00:31 +0000
Subject: [PATCH 06/22] Fix flexbox children being floored by padding/border
---
src/compute/flexbox.rs | 94 +++++++++++++++++++++++++-----------------
1 file changed, 56 insertions(+), 38 deletions(-)
diff --git a/src/compute/flexbox.rs b/src/compute/flexbox.rs
index ba88eb606..25456cade 100644
--- a/src/compute/flexbox.rs
+++ b/src/compute/flexbox.rs
@@ -687,15 +687,15 @@ fn determine_flex_base_size(
child.inner_flex_basis =
child.flex_basis - child.padding.main_axis_sum(constants.dir) - child.border.main_axis_sum(constants.dir);
- let hypothetical_inner_min_main = child.min_size.main(constants.dir);
- child.hypothetical_inner_size.set_main(
- constants.dir,
- child.flex_basis.maybe_clamp(hypothetical_inner_min_main, child.max_size.main(constants.dir)),
- );
- child.hypothetical_outer_size.set_main(
- constants.dir,
- child.hypothetical_inner_size.main(constants.dir) + child.margin.main_axis_sum(constants.dir),
- );
+ let padding_border_axes_sums = (child.padding + child.border).sum_axes().map(Some);
+ let hypothetical_inner_min_main =
+ child.min_size.main(constants.dir).maybe_max(padding_border_axes_sums.main(constants.dir));
+ let hypothetical_inner_size =
+ child.flex_basis.maybe_clamp(hypothetical_inner_min_main, child.max_size.main(constants.dir));
+ let hypothetical_outer_size = hypothetical_inner_size + child.margin.main_axis_sum(constants.dir);
+
+ child.hypothetical_inner_size.set_main(constants.dir, hypothetical_inner_size);
+ child.hypothetical_outer_size.set_main(constants.dir, hypothetical_outer_size);
let min_content_size = GenericAlgorithm::measure_size(
tree,
@@ -709,7 +709,8 @@ fn determine_flex_base_size(
// 4.5. Automatic Minimum Size of Flex Items
// https://www.w3.org/TR/css-flexbox-1/#min-size-auto
let clamped_min_content_size = min_content_size.maybe_min(child.size).maybe_min(child.max_size);
- child.resolved_minimum_size = child.min_size.unwrap_or(clamped_min_content_size);
+ child.resolved_minimum_size =
+ child.min_size.unwrap_or(clamped_min_content_size).maybe_max(padding_border_axes_sums);
}
}
@@ -810,7 +811,10 @@ fn determine_container_main_size(
let total_target_size = line
.items
.iter()
- .map(|child| child.flex_basis + child.margin.main_axis_sum(constants.dir))
+ .map(|child| {
+ let padding_border_sum = (child.padding + child.border).main_axis_sum(constants.dir);
+ (child.flex_basis + child.margin.main_axis_sum(constants.dir)).max(padding_border_sum)
+ })
.sum::();
total_target_size + line_main_axis_gap
})
@@ -831,7 +835,10 @@ fn determine_container_main_size(
let total_target_size = line
.items
.iter()
- .map(|child| child.flex_basis + child.margin.main_axis_sum(constants.dir))
+ .map(|child| {
+ let padding_border_sum = (child.padding + child.border).main_axis_sum(constants.dir);
+ (child.flex_basis + child.margin.main_axis_sum(constants.dir)).max(padding_border_sum)
+ })
.sum::();
total_target_size + line_main_axis_gap
})
@@ -852,21 +859,27 @@ fn determine_container_main_size(
let style_max = item.max_size.main(constants.dir);
let flex_basis_min = Some(item.flex_basis).filter(|_| item.flex_shrink == 0.0);
let flex_basis_max = Some(item.flex_basis).filter(|_| item.flex_grow == 0.0);
- let min_main_size = style_min.maybe_max(flex_basis_min).or(flex_basis_min);
- let max_main_size = style_max.maybe_min(flex_basis_max).or(flex_basis_max);
+ let resolved_min = item.resolved_minimum_size.main(constants.dir);
+ let min_main_size = style_min
+ .maybe_max(flex_basis_min)
+ .or(flex_basis_min)
+ .unwrap_or(resolved_min)
+ .max(resolved_min);
+ let max_main_size =
+ style_max.maybe_min(flex_basis_max).or(flex_basis_max).unwrap_or(f32::INFINITY);
let content_contribution = match (min_main_size, style_preferred, max_main_size) {
// If the clamping values are such that max <= min, then we can avoid the expensive step of computing the content size
// as we know that the clamping values will override it anyway
- (Some(min), Some(pref), Some(max)) if max <= min || max <= pref => {
+ (min, Some(pref), max) if max <= min || max <= pref => {
pref.min(max).max(min) + item.margin.main_axis_sum(constants.dir)
}
- (Some(min), _, Some(max)) if max <= min => min + item.margin.main_axis_sum(constants.dir),
- (_, Some(pref), Some(max)) if max <= pref => max + item.margin.main_axis_sum(constants.dir),
+ (min, _, max) if max <= min => min + item.margin.main_axis_sum(constants.dir),
// Else compute the min- or -max content size and apply the full formula for computing the
// min- or max- content contributuon
_ => {
// Either the min- or max- content size depending on which constraint we are sizing under.
+ // TODO: Optimise by using already computed values where available
let content_main_size = GenericAlgorithm::measure_size(
tree,
item.node,
@@ -891,9 +904,14 @@ fn determine_container_main_size(
// Ultimately, this was not found by reading the spec, but by trial and error fixing tests to align with Webkit/Firefox output.
// (see the `flex_basis_unconstraint_row` and `flex_basis_uncontraint_column` generated tests which demonstrate this)
if constants.is_row {
- content_main_size.maybe_clamp(style_min, style_max)
+ content_main_size
+ .maybe_clamp(style_min, style_max)
+ .max(constants.padding_border.main_axis_sum(constants.dir))
} else {
- content_main_size.max(item.flex_basis).maybe_clamp(style_min, style_max)
+ content_main_size
+ .max(item.flex_basis)
+ .maybe_clamp(style_min, style_max)
+ .max(constants.padding_border.main_axis_sum(constants.dir))
}
}
};
@@ -1162,13 +1180,15 @@ fn determine_hypothetical_cross_size(
available_space: Size,
) {
for child in line.items.iter_mut() {
+ let padding_border_sum = (child.padding + child.border).cross_axis_sum(constants.dir);
+
let child_cross = child
.size
.cross(constants.dir)
- .maybe_clamp(child.min_size.cross(constants.dir), child.max_size.cross(constants.dir));
+ .maybe_clamp(child.min_size.cross(constants.dir), child.max_size.cross(constants.dir))
+ .maybe_max(padding_border_sum);
- child.hypothetical_inner_size.set_cross(
- constants.dir,
+ let child_inner_cross = child_cross.unwrap_or_else(|| {
GenericAlgorithm::measure_size(
tree,
child.node,
@@ -1192,13 +1212,13 @@ fn determine_hypothetical_cross_size(
SizingMode::ContentSize,
)
.cross(constants.dir)
- .maybe_clamp(child.min_size.cross(constants.dir), child.max_size.cross(constants.dir)),
- );
+ .maybe_clamp(child.min_size.cross(constants.dir), child.max_size.cross(constants.dir))
+ .max(padding_border_sum)
+ });
+ let child_outer_cross = child_inner_cross + child.margin.cross_axis_sum(constants.dir);
- child.hypothetical_outer_size.set_cross(
- constants.dir,
- child.hypothetical_inner_size.cross(constants.dir) + child.margin.cross_axis_sum(constants.dir),
- );
+ child.hypothetical_inner_size.set_cross(constants.dir, child_inner_cross);
+ child.hypothetical_outer_size.set_cross(constants.dir, child_outer_cross);
}
}
@@ -1600,17 +1620,15 @@ fn determine_container_cross_size(
let total_cross_axis_gap = sum_axis_gaps(constants.gap.cross(constants.dir), flex_lines.len());
let total_line_cross_size: f32 = flex_lines.iter().map(|line| line.cross_size).sum::();
- constants.container_size.set_cross(
- constants.dir,
- node_size.cross(constants.dir).unwrap_or(
- total_line_cross_size + total_cross_axis_gap + constants.padding_border.cross_axis_sum(constants.dir),
- ),
- );
+ let padding_border_sum = constants.padding_border.cross_axis_sum(constants.dir);
+ let outer_container_size = node_size
+ .cross(constants.dir)
+ .unwrap_or(total_line_cross_size + total_cross_axis_gap + padding_border_sum)
+ .max(padding_border_sum);
+ let inner_container_size = outer_container_size - padding_border_sum;
- constants.inner_container_size.set_cross(
- constants.dir,
- constants.container_size.cross(constants.dir) - constants.padding_border.cross_axis_sum(constants.dir),
- );
+ constants.container_size.set_cross(constants.dir, outer_container_size);
+ constants.inner_container_size.set_cross(constants.dir, inner_container_size);
total_line_cross_size
}
From 7a621e62687978825147f4a81c13af8fa74b6c1d Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 22:17:46 +0000
Subject: [PATCH 07/22] Combine padding and border tests + make edge dimensions
uneven
---
.../leaf_border_overrides_min_size.html | 15 --------
test_fixtures/leaf_border_overrides_size.html | 15 --------
...eaf_padding_border_overrides_max_size.html | 15 ++++++++
...af_padding_border_overrides_min_size.html} | 2 +-
...> leaf_padding_border_overrides_size.html} | 2 +-
.../leaf_padding_overrides_max_size.html | 15 --------
.../leaf_padding_overrides_size.html | 15 --------
...=> padding_border_overrides_max_size.html} | 2 +-
...=> padding_border_overrides_min_size.html} | 2 +-
...tml => padding_border_overrides_size.html} | 2 +-
test_fixtures/padding_overrides_max_size.html | 17 ---------
test_fixtures/padding_overrides_min_size.html | 17 ---------
test_fixtures/padding_overrides_size.html | 17 ---------
tests/generated/border_overrides_max_size.rs | 37 -------------------
tests/generated/border_overrides_min_size.rs | 37 -------------------
tests/generated/border_overrides_size.rs | 37 -------------------
.../leaf_border_overrides_max_size.rs | 31 ----------------
.../leaf_border_overrides_min_size.rs | 31 ----------------
tests/generated/leaf_border_overrides_size.rs | 31 ----------------
.../leaf_padding_border_overrides_max_size.rs | 37 +++++++++++++++++++
...leaf_padding_border_overrides_min_size.rs} | 20 ++++++----
.../leaf_padding_border_overrides_size.rs | 37 +++++++++++++++++++
.../leaf_padding_overrides_max_size.rs | 31 ----------------
.../generated/leaf_padding_overrides_size.rs | 31 ----------------
tests/generated/mod.rs | 18 +++------
...s => padding_border_overrides_max_size.rs} | 28 ++++++++------
...s => padding_border_overrides_min_size.rs} | 24 +++++++-----
...ze.rs => padding_border_overrides_size.rs} | 28 ++++++++------
28 files changed, 162 insertions(+), 432 deletions(-)
delete mode 100644 test_fixtures/leaf_border_overrides_min_size.html
delete mode 100644 test_fixtures/leaf_border_overrides_size.html
create mode 100644 test_fixtures/leaf_padding_border_overrides_max_size.html
rename test_fixtures/{leaf_padding_overrides_min_size.html => leaf_padding_border_overrides_min_size.html} (77%)
rename test_fixtures/{leaf_border_overrides_max_size.html => leaf_padding_border_overrides_size.html} (63%)
delete mode 100644 test_fixtures/leaf_padding_overrides_max_size.html
delete mode 100644 test_fixtures/leaf_padding_overrides_size.html
rename test_fixtures/{border_overrides_size.html => padding_border_overrides_max_size.html} (66%)
rename test_fixtures/{border_overrides_min_size.html => padding_border_overrides_min_size.html} (66%)
rename test_fixtures/{border_overrides_max_size.html => padding_border_overrides_size.html} (67%)
delete mode 100644 test_fixtures/padding_overrides_max_size.html
delete mode 100644 test_fixtures/padding_overrides_min_size.html
delete mode 100644 test_fixtures/padding_overrides_size.html
delete mode 100644 tests/generated/border_overrides_max_size.rs
delete mode 100644 tests/generated/border_overrides_min_size.rs
delete mode 100644 tests/generated/border_overrides_size.rs
delete mode 100644 tests/generated/leaf_border_overrides_max_size.rs
delete mode 100644 tests/generated/leaf_border_overrides_min_size.rs
delete mode 100644 tests/generated/leaf_border_overrides_size.rs
create mode 100644 tests/generated/leaf_padding_border_overrides_max_size.rs
rename tests/generated/{leaf_padding_overrides_min_size.rs => leaf_padding_border_overrides_min_size.rs} (53%)
create mode 100644 tests/generated/leaf_padding_border_overrides_size.rs
delete mode 100644 tests/generated/leaf_padding_overrides_max_size.rs
delete mode 100644 tests/generated/leaf_padding_overrides_size.rs
rename tests/generated/{padding_overrides_max_size.rs => padding_border_overrides_max_size.rs} (50%)
rename tests/generated/{padding_overrides_min_size.rs => padding_border_overrides_min_size.rs} (55%)
rename tests/generated/{padding_overrides_size.rs => padding_border_overrides_size.rs} (50%)
diff --git a/test_fixtures/leaf_border_overrides_min_size.html b/test_fixtures/leaf_border_overrides_min_size.html
deleted file mode 100644
index c46010bad..000000000
--- a/test_fixtures/leaf_border_overrides_min_size.html
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
-
-
-
-
- Test description
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/test_fixtures/leaf_border_overrides_size.html b/test_fixtures/leaf_border_overrides_size.html
deleted file mode 100644
index 4025c8ab3..000000000
--- a/test_fixtures/leaf_border_overrides_size.html
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
-
-
-
-
- Test description
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/test_fixtures/leaf_padding_border_overrides_max_size.html b/test_fixtures/leaf_padding_border_overrides_max_size.html
new file mode 100644
index 000000000..99f440a8b
--- /dev/null
+++ b/test_fixtures/leaf_padding_border_overrides_max_size.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/leaf_padding_overrides_min_size.html b/test_fixtures/leaf_padding_border_overrides_min_size.html
similarity index 77%
rename from test_fixtures/leaf_padding_overrides_min_size.html
rename to test_fixtures/leaf_padding_border_overrides_min_size.html
index f570321c8..0482e8258 100644
--- a/test_fixtures/leaf_padding_overrides_min_size.html
+++ b/test_fixtures/leaf_padding_border_overrides_min_size.html
@@ -9,7 +9,7 @@
-
+
\ No newline at end of file
diff --git a/test_fixtures/leaf_border_overrides_max_size.html b/test_fixtures/leaf_padding_border_overrides_size.html
similarity index 63%
rename from test_fixtures/leaf_border_overrides_max_size.html
rename to test_fixtures/leaf_padding_border_overrides_size.html
index dadfac53c..8aa54d19e 100644
--- a/test_fixtures/leaf_border_overrides_max_size.html
+++ b/test_fixtures/leaf_padding_border_overrides_size.html
@@ -9,7 +9,7 @@
-
+
\ No newline at end of file
diff --git a/test_fixtures/leaf_padding_overrides_max_size.html b/test_fixtures/leaf_padding_overrides_max_size.html
deleted file mode 100644
index 4652fc4db..000000000
--- a/test_fixtures/leaf_padding_overrides_max_size.html
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
-
-
-
-
- Test description
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/test_fixtures/leaf_padding_overrides_size.html b/test_fixtures/leaf_padding_overrides_size.html
deleted file mode 100644
index 4824b8b1a..000000000
--- a/test_fixtures/leaf_padding_overrides_size.html
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
-
-
-
-
- Test description
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/test_fixtures/border_overrides_size.html b/test_fixtures/padding_border_overrides_max_size.html
similarity index 66%
rename from test_fixtures/border_overrides_size.html
rename to test_fixtures/padding_border_overrides_max_size.html
index f0ac72df8..6d0bf7cf1 100644
--- a/test_fixtures/border_overrides_size.html
+++ b/test_fixtures/padding_border_overrides_max_size.html
@@ -10,7 +10,7 @@
-
+
diff --git a/test_fixtures/border_overrides_min_size.html b/test_fixtures/padding_border_overrides_min_size.html
similarity index 66%
rename from test_fixtures/border_overrides_min_size.html
rename to test_fixtures/padding_border_overrides_min_size.html
index 817e820f4..d8223127a 100644
--- a/test_fixtures/border_overrides_min_size.html
+++ b/test_fixtures/padding_border_overrides_min_size.html
@@ -10,7 +10,7 @@
-
+
diff --git a/test_fixtures/border_overrides_max_size.html b/test_fixtures/padding_border_overrides_size.html
similarity index 67%
rename from test_fixtures/border_overrides_max_size.html
rename to test_fixtures/padding_border_overrides_size.html
index 92769ac00..7b2ed62d2 100644
--- a/test_fixtures/border_overrides_max_size.html
+++ b/test_fixtures/padding_border_overrides_size.html
@@ -10,7 +10,7 @@
-
-
-
\ No newline at end of file
diff --git a/test_fixtures/padding_overrides_min_size.html b/test_fixtures/padding_overrides_min_size.html
deleted file mode 100644
index 286832e13..000000000
--- a/test_fixtures/padding_overrides_min_size.html
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-
-
-
-
- Test description
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/test_fixtures/padding_overrides_size.html b/test_fixtures/padding_overrides_size.html
deleted file mode 100644
index e5779fbf3..000000000
--- a/test_fixtures/padding_overrides_size.html
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-
-
-
-
- Test description
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/tests/generated/border_overrides_max_size.rs b/tests/generated/border_overrides_max_size.rs
deleted file mode 100644
index eb0c1aa00..000000000
--- a/tests/generated/border_overrides_max_size.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#[test]
-fn border_overrides_max_size() {
- use slotmap::Key;
- #[allow(unused_imports)]
- use taffy::{layout::Layout, prelude::*};
- let mut taffy = taffy::Taffy::new();
- let node0 = taffy
- .new_leaf(taffy::style::Style {
- max_size: taffy::geometry::Size {
- width: taffy::style::Dimension::Points(5f32),
- height: taffy::style::Dimension::Points(5f32),
- },
- border: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
- },
- ..Default::default()
- })
- .unwrap();
- let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
- taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
- println!("\nComputed tree:");
- taffy::debug::print_tree(&taffy, node);
- println!();
- let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
- let Layout { size, location, .. } = taffy.layout(node0).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
-}
diff --git a/tests/generated/border_overrides_min_size.rs b/tests/generated/border_overrides_min_size.rs
deleted file mode 100644
index ce5cb315a..000000000
--- a/tests/generated/border_overrides_min_size.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#[test]
-fn border_overrides_min_size() {
- use slotmap::Key;
- #[allow(unused_imports)]
- use taffy::{layout::Layout, prelude::*};
- let mut taffy = taffy::Taffy::new();
- let node0 = taffy
- .new_leaf(taffy::style::Style {
- min_size: taffy::geometry::Size {
- width: taffy::style::Dimension::Points(0f32),
- height: taffy::style::Dimension::Points(0f32),
- },
- border: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
- },
- ..Default::default()
- })
- .unwrap();
- let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
- taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
- println!("\nComputed tree:");
- taffy::debug::print_tree(&taffy, node);
- println!();
- let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
- let Layout { size, location, .. } = taffy.layout(node0).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
-}
diff --git a/tests/generated/border_overrides_size.rs b/tests/generated/border_overrides_size.rs
deleted file mode 100644
index 55aae4e12..000000000
--- a/tests/generated/border_overrides_size.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#[test]
-fn border_overrides_size() {
- use slotmap::Key;
- #[allow(unused_imports)]
- use taffy::{layout::Layout, prelude::*};
- let mut taffy = taffy::Taffy::new();
- let node0 = taffy
- .new_leaf(taffy::style::Style {
- size: taffy::geometry::Size {
- width: taffy::style::Dimension::Points(5f32),
- height: taffy::style::Dimension::Points(5f32),
- },
- border: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
- },
- ..Default::default()
- })
- .unwrap();
- let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
- taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
- println!("\nComputed tree:");
- taffy::debug::print_tree(&taffy, node);
- println!();
- let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
- let Layout { size, location, .. } = taffy.layout(node0).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
-}
diff --git a/tests/generated/leaf_border_overrides_max_size.rs b/tests/generated/leaf_border_overrides_max_size.rs
deleted file mode 100644
index e914ef118..000000000
--- a/tests/generated/leaf_border_overrides_max_size.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#[test]
-fn leaf_border_overrides_max_size() {
- use slotmap::Key;
- #[allow(unused_imports)]
- use taffy::{layout::Layout, prelude::*};
- let mut taffy = taffy::Taffy::new();
- let node = taffy
- .new_leaf(taffy::style::Style {
- max_size: taffy::geometry::Size {
- width: taffy::style::Dimension::Points(5f32),
- height: taffy::style::Dimension::Points(5f32),
- },
- border: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
- },
- ..Default::default()
- })
- .unwrap();
- taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
- println!("\nComputed tree:");
- taffy::debug::print_tree(&taffy, node);
- println!();
- let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
-}
diff --git a/tests/generated/leaf_border_overrides_min_size.rs b/tests/generated/leaf_border_overrides_min_size.rs
deleted file mode 100644
index 2681bf73d..000000000
--- a/tests/generated/leaf_border_overrides_min_size.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#[test]
-fn leaf_border_overrides_min_size() {
- use slotmap::Key;
- #[allow(unused_imports)]
- use taffy::{layout::Layout, prelude::*};
- let mut taffy = taffy::Taffy::new();
- let node = taffy
- .new_leaf(taffy::style::Style {
- min_size: taffy::geometry::Size {
- width: taffy::style::Dimension::Points(0f32),
- height: taffy::style::Dimension::Points(0f32),
- },
- border: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
- },
- ..Default::default()
- })
- .unwrap();
- taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
- println!("\nComputed tree:");
- taffy::debug::print_tree(&taffy, node);
- println!();
- let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
-}
diff --git a/tests/generated/leaf_border_overrides_size.rs b/tests/generated/leaf_border_overrides_size.rs
deleted file mode 100644
index 1f99cab4f..000000000
--- a/tests/generated/leaf_border_overrides_size.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#[test]
-fn leaf_border_overrides_size() {
- use slotmap::Key;
- #[allow(unused_imports)]
- use taffy::{layout::Layout, prelude::*};
- let mut taffy = taffy::Taffy::new();
- let node = taffy
- .new_leaf(taffy::style::Style {
- size: taffy::geometry::Size {
- width: taffy::style::Dimension::Points(5f32),
- height: taffy::style::Dimension::Points(5f32),
- },
- border: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
- },
- ..Default::default()
- })
- .unwrap();
- taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
- println!("\nComputed tree:");
- taffy::debug::print_tree(&taffy, node);
- println!();
- let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
-}
diff --git a/tests/generated/leaf_padding_border_overrides_max_size.rs b/tests/generated/leaf_padding_border_overrides_max_size.rs
new file mode 100644
index 000000000..3f61a2b56
--- /dev/null
+++ b/tests/generated/leaf_padding_border_overrides_max_size.rs
@@ -0,0 +1,37 @@
+#[test]
+fn leaf_padding_border_overrides_max_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ max_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/leaf_padding_overrides_min_size.rs b/tests/generated/leaf_padding_border_overrides_min_size.rs
similarity index 53%
rename from tests/generated/leaf_padding_overrides_min_size.rs
rename to tests/generated/leaf_padding_border_overrides_min_size.rs
index 8d38d4898..44323f5bb 100644
--- a/tests/generated/leaf_padding_overrides_min_size.rs
+++ b/tests/generated/leaf_padding_border_overrides_min_size.rs
@@ -1,5 +1,5 @@
#[test]
-fn leaf_padding_overrides_min_size() {
+fn leaf_padding_border_overrides_min_size() {
use slotmap::Key;
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
@@ -11,10 +11,16 @@ fn leaf_padding_overrides_min_size() {
height: taffy::style::Dimension::Points(0f32),
},
padding: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
},
..Default::default()
})
@@ -24,8 +30,8 @@ fn leaf_padding_overrides_min_size() {
taffy::debug::print_tree(&taffy, node);
println!();
let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
}
diff --git a/tests/generated/leaf_padding_border_overrides_size.rs b/tests/generated/leaf_padding_border_overrides_size.rs
new file mode 100644
index 000000000..631c85b54
--- /dev/null
+++ b/tests/generated/leaf_padding_border_overrides_size.rs
@@ -0,0 +1,37 @@
+#[test]
+fn leaf_padding_border_overrides_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node = taffy
+ .new_leaf(taffy::style::Style {
+ size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+}
diff --git a/tests/generated/leaf_padding_overrides_max_size.rs b/tests/generated/leaf_padding_overrides_max_size.rs
deleted file mode 100644
index 43ae81573..000000000
--- a/tests/generated/leaf_padding_overrides_max_size.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#[test]
-fn leaf_padding_overrides_max_size() {
- use slotmap::Key;
- #[allow(unused_imports)]
- use taffy::{layout::Layout, prelude::*};
- let mut taffy = taffy::Taffy::new();
- let node = taffy
- .new_leaf(taffy::style::Style {
- max_size: taffy::geometry::Size {
- width: taffy::style::Dimension::Points(5f32),
- height: taffy::style::Dimension::Points(5f32),
- },
- padding: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
- },
- ..Default::default()
- })
- .unwrap();
- taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
- println!("\nComputed tree:");
- taffy::debug::print_tree(&taffy, node);
- println!();
- let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
-}
diff --git a/tests/generated/leaf_padding_overrides_size.rs b/tests/generated/leaf_padding_overrides_size.rs
deleted file mode 100644
index 51164cd95..000000000
--- a/tests/generated/leaf_padding_overrides_size.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#[test]
-fn leaf_padding_overrides_size() {
- use slotmap::Key;
- #[allow(unused_imports)]
- use taffy::{layout::Layout, prelude::*};
- let mut taffy = taffy::Taffy::new();
- let node = taffy
- .new_leaf(taffy::style::Style {
- size: taffy::geometry::Size {
- width: taffy::style::Dimension::Points(5f32),
- height: taffy::style::Dimension::Points(5f32),
- },
- padding: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
- },
- ..Default::default()
- })
- .unwrap();
- taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
- println!("\nComputed tree:");
- taffy::debug::print_tree(&taffy, node);
- println!();
- let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
- assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
- assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
-}
diff --git a/tests/generated/mod.rs b/tests/generated/mod.rs
index 4827c16e6..589022132 100644
--- a/tests/generated/mod.rs
+++ b/tests/generated/mod.rs
@@ -204,9 +204,6 @@ mod border_container_match_child;
mod border_flex_child;
mod border_no_child;
mod border_no_size;
-mod border_overrides_max_size;
-mod border_overrides_min_size;
-mod border_overrides_size;
mod border_stretch_child;
mod child_min_max_width_flexing;
mod child_with_padding_align_end;
@@ -753,12 +750,9 @@ mod justify_content_row_min_width_and_margin;
mod justify_content_row_space_around;
mod justify_content_row_space_between;
mod justify_content_row_space_evenly;
-mod leaf_border_overrides_max_size;
-mod leaf_border_overrides_min_size;
-mod leaf_border_overrides_size;
-mod leaf_padding_overrides_max_size;
-mod leaf_padding_overrides_min_size;
-mod leaf_padding_overrides_size;
+mod leaf_padding_border_overrides_max_size;
+mod leaf_padding_border_overrides_min_size;
+mod leaf_padding_border_overrides_size;
mod margin_and_flex_column;
mod margin_and_flex_row;
mod margin_and_stretch_column;
@@ -829,14 +823,14 @@ mod only_shrinkable_item_with_flex_basis_zero;
mod overflow_cross_axis;
mod overflow_main_axis;
mod padding_align_end_child;
+mod padding_border_overrides_max_size;
+mod padding_border_overrides_min_size;
+mod padding_border_overrides_size;
mod padding_center_child;
mod padding_container_match_child;
mod padding_flex_child;
mod padding_no_child;
mod padding_no_size;
-mod padding_overrides_max_size;
-mod padding_overrides_min_size;
-mod padding_overrides_size;
mod padding_stretch_child;
mod parent_wrap_child_size_overflowing_parent;
mod percent_absolute_position;
diff --git a/tests/generated/padding_overrides_max_size.rs b/tests/generated/padding_border_overrides_max_size.rs
similarity index 50%
rename from tests/generated/padding_overrides_max_size.rs
rename to tests/generated/padding_border_overrides_max_size.rs
index 16a38166d..205073386 100644
--- a/tests/generated/padding_overrides_max_size.rs
+++ b/tests/generated/padding_border_overrides_max_size.rs
@@ -1,5 +1,5 @@
#[test]
-fn padding_overrides_max_size() {
+fn padding_border_overrides_max_size() {
use slotmap::Key;
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
@@ -7,14 +7,20 @@ fn padding_overrides_max_size() {
let node0 = taffy
.new_leaf(taffy::style::Style {
max_size: taffy::geometry::Size {
- width: taffy::style::Dimension::Points(5f32),
- height: taffy::style::Dimension::Points(5f32),
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
},
padding: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
},
..Default::default()
})
@@ -25,13 +31,13 @@ fn padding_overrides_max_size() {
taffy::debug::print_tree(&taffy, node);
println!();
let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
let Layout { size, location, .. } = taffy.layout(node0).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 14f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
}
diff --git a/tests/generated/padding_overrides_min_size.rs b/tests/generated/padding_border_overrides_min_size.rs
similarity index 55%
rename from tests/generated/padding_overrides_min_size.rs
rename to tests/generated/padding_border_overrides_min_size.rs
index 5dea4e063..6b59e23db 100644
--- a/tests/generated/padding_overrides_min_size.rs
+++ b/tests/generated/padding_border_overrides_min_size.rs
@@ -1,5 +1,5 @@
#[test]
-fn padding_overrides_min_size() {
+fn padding_border_overrides_min_size() {
use slotmap::Key;
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
@@ -11,10 +11,16 @@ fn padding_overrides_min_size() {
height: taffy::style::Dimension::Points(0f32),
},
padding: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
},
..Default::default()
})
@@ -25,13 +31,13 @@ fn padding_overrides_min_size() {
taffy::debug::print_tree(&taffy, node);
println!();
let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
let Layout { size, location, .. } = taffy.layout(node0).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 14f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
}
diff --git a/tests/generated/padding_overrides_size.rs b/tests/generated/padding_border_overrides_size.rs
similarity index 50%
rename from tests/generated/padding_overrides_size.rs
rename to tests/generated/padding_border_overrides_size.rs
index f076ffbe5..627b3e968 100644
--- a/tests/generated/padding_overrides_size.rs
+++ b/tests/generated/padding_border_overrides_size.rs
@@ -1,5 +1,5 @@
#[test]
-fn padding_overrides_size() {
+fn padding_border_overrides_size() {
use slotmap::Key;
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
@@ -7,14 +7,20 @@ fn padding_overrides_size() {
let node0 = taffy
.new_leaf(taffy::style::Style {
size: taffy::geometry::Size {
- width: taffy::style::Dimension::Points(5f32),
- height: taffy::style::Dimension::Points(5f32),
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
},
padding: taffy::geometry::Rect {
- left: taffy::style::LengthPercentage::Points(10f32),
- right: taffy::style::LengthPercentage::Points(10f32),
- top: taffy::style::LengthPercentage::Points(10f32),
- bottom: taffy::style::LengthPercentage::Points(10f32),
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
},
..Default::default()
})
@@ -25,13 +31,13 @@ fn padding_overrides_size() {
taffy::debug::print_tree(&taffy, node);
println!();
let Layout { size, location, .. } = taffy.layout(node).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 20f32, size.height);
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
let Layout { size, location, .. } = taffy.layout(node0).unwrap();
- assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.width);
- assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 20f32, size.height);
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 14f32, size.height);
assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
}
From d521c1e8f8adb47148f2b32a4d9f2959d07637ba Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 22:19:26 +0000
Subject: [PATCH 08/22] Add padding/border floor absolute child size
---
...ute_padding_border_overrides_max_size.html | 17 +++++++
...bsolute_padding_border_overrides_size.html | 17 +++++++
...olute_padding_border_overrides_max_size.rs | 44 +++++++++++++++++++
.../absolute_padding_border_overrides_size.rs | 44 +++++++++++++++++++
tests/generated/mod.rs | 2 +
5 files changed, 124 insertions(+)
create mode 100644 test_fixtures/absolute_padding_border_overrides_max_size.html
create mode 100644 test_fixtures/absolute_padding_border_overrides_size.html
create mode 100644 tests/generated/absolute_padding_border_overrides_max_size.rs
create mode 100644 tests/generated/absolute_padding_border_overrides_size.rs
diff --git a/test_fixtures/absolute_padding_border_overrides_max_size.html b/test_fixtures/absolute_padding_border_overrides_max_size.html
new file mode 100644
index 000000000..04f16a34a
--- /dev/null
+++ b/test_fixtures/absolute_padding_border_overrides_max_size.html
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/absolute_padding_border_overrides_size.html b/test_fixtures/absolute_padding_border_overrides_size.html
new file mode 100644
index 000000000..6cbc088af
--- /dev/null
+++ b/test_fixtures/absolute_padding_border_overrides_size.html
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/generated/absolute_padding_border_overrides_max_size.rs b/tests/generated/absolute_padding_border_overrides_max_size.rs
new file mode 100644
index 000000000..b90bda2da
--- /dev/null
+++ b/tests/generated/absolute_padding_border_overrides_max_size.rs
@@ -0,0 +1,44 @@
+#[test]
+fn absolute_padding_border_overrides_max_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node0 = taffy
+ .new_leaf(taffy::style::Style {
+ position: taffy::style::Position::Absolute,
+ max_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 0f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 0f32, size.width);
+ assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 0f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
+}
diff --git a/tests/generated/absolute_padding_border_overrides_size.rs b/tests/generated/absolute_padding_border_overrides_size.rs
new file mode 100644
index 000000000..f4303f2d8
--- /dev/null
+++ b/tests/generated/absolute_padding_border_overrides_size.rs
@@ -0,0 +1,44 @@
+#[test]
+fn absolute_padding_border_overrides_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node0 = taffy
+ .new_leaf(taffy::style::Style {
+ position: taffy::style::Position::Absolute,
+ size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 0f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 0f32, size.width);
+ assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 0f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
+}
diff --git a/tests/generated/mod.rs b/tests/generated/mod.rs
index 589022132..5c954e4c8 100644
--- a/tests/generated/mod.rs
+++ b/tests/generated/mod.rs
@@ -104,6 +104,8 @@ mod absolute_minmax_bottom_right_min_max;
mod absolute_minmax_bottom_right_min_max_preferred;
mod absolute_minmax_top_left_bottom_right_max;
mod absolute_minmax_top_left_bottom_right_min_max;
+mod absolute_padding_border_overrides_max_size;
+mod absolute_padding_border_overrides_size;
mod align_baseline;
mod align_baseline_child;
mod align_baseline_child_margin;
From 2294aff13456bdf58a0a3163c43104aadc25a692 Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 22:30:21 +0000
Subject: [PATCH 09/22] Add padding/border floor node size tests for grid
---
...rid_padding_border_overrides_max_size.html | 17 +++++++
...rid_padding_border_overrides_min_size.html | 17 +++++++
.../grid_padding_border_overrides_size.html | 17 +++++++
.../grid_padding_border_overrides_max_size.rs | 45 +++++++++++++++++++
.../grid_padding_border_overrides_min_size.rs | 45 +++++++++++++++++++
.../grid_padding_border_overrides_size.rs | 45 +++++++++++++++++++
tests/generated/mod.rs | 6 +++
7 files changed, 192 insertions(+)
create mode 100644 test_fixtures/grid_padding_border_overrides_max_size.html
create mode 100644 test_fixtures/grid_padding_border_overrides_min_size.html
create mode 100644 test_fixtures/grid_padding_border_overrides_size.html
create mode 100644 tests/generated/grid_padding_border_overrides_max_size.rs
create mode 100644 tests/generated/grid_padding_border_overrides_min_size.rs
create mode 100644 tests/generated/grid_padding_border_overrides_size.rs
diff --git a/test_fixtures/grid_padding_border_overrides_max_size.html b/test_fixtures/grid_padding_border_overrides_max_size.html
new file mode 100644
index 000000000..41ec1e05d
--- /dev/null
+++ b/test_fixtures/grid_padding_border_overrides_max_size.html
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/grid_padding_border_overrides_min_size.html b/test_fixtures/grid_padding_border_overrides_min_size.html
new file mode 100644
index 000000000..629e26a33
--- /dev/null
+++ b/test_fixtures/grid_padding_border_overrides_min_size.html
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/grid_padding_border_overrides_size.html b/test_fixtures/grid_padding_border_overrides_size.html
new file mode 100644
index 000000000..4612b1b38
--- /dev/null
+++ b/test_fixtures/grid_padding_border_overrides_size.html
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/generated/grid_padding_border_overrides_max_size.rs b/tests/generated/grid_padding_border_overrides_max_size.rs
new file mode 100644
index 000000000..2a874008c
--- /dev/null
+++ b/tests/generated/grid_padding_border_overrides_max_size.rs
@@ -0,0 +1,45 @@
+#[test]
+fn grid_padding_border_overrides_max_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node0 = taffy
+ .new_leaf(taffy::style::Style {
+ max_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ let node = taffy
+ .new_with_children(taffy::style::Style { display: taffy::style::Display::Grid, ..Default::default() }, &[node0])
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
+}
diff --git a/tests/generated/grid_padding_border_overrides_min_size.rs b/tests/generated/grid_padding_border_overrides_min_size.rs
new file mode 100644
index 000000000..16ca50031
--- /dev/null
+++ b/tests/generated/grid_padding_border_overrides_min_size.rs
@@ -0,0 +1,45 @@
+#[test]
+fn grid_padding_border_overrides_min_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node0 = taffy
+ .new_leaf(taffy::style::Style {
+ min_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(0f32),
+ height: taffy::style::Dimension::Points(0f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ let node = taffy
+ .new_with_children(taffy::style::Style { display: taffy::style::Display::Grid, ..Default::default() }, &[node0])
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
+}
diff --git a/tests/generated/grid_padding_border_overrides_size.rs b/tests/generated/grid_padding_border_overrides_size.rs
new file mode 100644
index 000000000..e2a5162b5
--- /dev/null
+++ b/tests/generated/grid_padding_border_overrides_size.rs
@@ -0,0 +1,45 @@
+#[test]
+fn grid_padding_border_overrides_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node0 = taffy
+ .new_leaf(taffy::style::Style {
+ size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ let node = taffy
+ .new_with_children(taffy::style::Style { display: taffy::style::Display::Grid, ..Default::default() }, &[node0])
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
+}
diff --git a/tests/generated/mod.rs b/tests/generated/mod.rs
index 5c954e4c8..8de8b9d9a 100644
--- a/tests/generated/mod.rs
+++ b/tests/generated/mod.rs
@@ -648,6 +648,12 @@ mod grid_out_of_order_items;
#[cfg(feature = "grid")]
mod grid_overflow_rows;
#[cfg(feature = "grid")]
+mod grid_padding_border_overrides_max_size;
+#[cfg(feature = "grid")]
+mod grid_padding_border_overrides_min_size;
+#[cfg(feature = "grid")]
+mod grid_padding_border_overrides_size;
+#[cfg(feature = "grid")]
mod grid_percent_item_inside_stretch_item;
#[cfg(feature = "grid")]
mod grid_percent_items_nested_inside_stretch_alignment;
From 6d7f9f1f0514b287c621c3a1765342ee0a32cd33 Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 22:31:59 +0000
Subject: [PATCH 10/22] Add grid container test for padding/border flooring
node size
---
...ner_padding_border_overrides_max_size.html | 17 +++++++
...ntainer_padding_border_overrides_size.html | 17 +++++++
...ainer_padding_border_overrides_max_size.rs | 47 +++++++++++++++++++
...container_padding_border_overrides_size.rs | 47 +++++++++++++++++++
tests/generated/mod.rs | 4 ++
5 files changed, 132 insertions(+)
create mode 100644 test_fixtures/grid_container_padding_border_overrides_max_size.html
create mode 100644 test_fixtures/grid_container_padding_border_overrides_size.html
create mode 100644 tests/generated/grid_container_padding_border_overrides_max_size.rs
create mode 100644 tests/generated/grid_container_padding_border_overrides_size.rs
diff --git a/test_fixtures/grid_container_padding_border_overrides_max_size.html b/test_fixtures/grid_container_padding_border_overrides_max_size.html
new file mode 100644
index 000000000..a58489fca
--- /dev/null
+++ b/test_fixtures/grid_container_padding_border_overrides_max_size.html
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/test_fixtures/grid_container_padding_border_overrides_size.html b/test_fixtures/grid_container_padding_border_overrides_size.html
new file mode 100644
index 000000000..a5cab4eed
--- /dev/null
+++ b/test_fixtures/grid_container_padding_border_overrides_size.html
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/generated/grid_container_padding_border_overrides_max_size.rs b/tests/generated/grid_container_padding_border_overrides_max_size.rs
new file mode 100644
index 000000000..dda3d1bc3
--- /dev/null
+++ b/tests/generated/grid_container_padding_border_overrides_max_size.rs
@@ -0,0 +1,47 @@
+#[test]
+fn grid_container_padding_border_overrides_max_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node0 = taffy.new_leaf(taffy::style::Style { ..Default::default() }).unwrap();
+ let node = taffy
+ .new_with_children(
+ taffy::style::Style {
+ display: taffy::style::Display::Grid,
+ max_size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
+ },
+ ..Default::default()
+ },
+ &[node0],
+ )
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 0f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, size.width);
+ assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, size.height);
+ assert_eq!(location.x, 15f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 15f32, location.x);
+ assert_eq!(location.y, 3f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 3f32, location.y);
+}
diff --git a/tests/generated/grid_container_padding_border_overrides_size.rs b/tests/generated/grid_container_padding_border_overrides_size.rs
new file mode 100644
index 000000000..55c1bdd20
--- /dev/null
+++ b/tests/generated/grid_container_padding_border_overrides_size.rs
@@ -0,0 +1,47 @@
+#[test]
+fn grid_container_padding_border_overrides_size() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node0 = taffy.new_leaf(taffy::style::Style { ..Default::default() }).unwrap();
+ let node = taffy
+ .new_with_children(
+ taffy::style::Style {
+ display: taffy::style::Display::Grid,
+ size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
+ },
+ ..Default::default()
+ },
+ &[node0],
+ )
+ .unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 22f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 22f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 0f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, size.width);
+ assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, size.height);
+ assert_eq!(location.x, 15f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 15f32, location.x);
+ assert_eq!(location.y, 3f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 3f32, location.y);
+}
diff --git a/tests/generated/mod.rs b/tests/generated/mod.rs
index 8de8b9d9a..f963beca8 100644
--- a/tests/generated/mod.rs
+++ b/tests/generated/mod.rs
@@ -466,6 +466,10 @@ mod grid_basic_with_overflow;
#[cfg(feature = "grid")]
mod grid_basic_with_padding;
#[cfg(feature = "grid")]
+mod grid_container_padding_border_overrides_max_size;
+#[cfg(feature = "grid")]
+mod grid_container_padding_border_overrides_size;
+#[cfg(feature = "grid")]
mod grid_display_none_fixed_size;
#[cfg(feature = "grid")]
mod grid_fit_content_percent_definite_argument;
From cfa4fec92bb006c95380ee0e772c9d6a328d5311 Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 23:17:36 +0000
Subject: [PATCH 11/22] Fix padding/border flooring size of absolutely
positioned children
---
src/compute/flexbox.rs | 13 ++++++++++---
1 file changed, 10 insertions(+), 3 deletions(-)
diff --git a/src/compute/flexbox.rs b/src/compute/flexbox.rs
index 25456cade..12bf91ddb 100644
--- a/src/compute/flexbox.rs
+++ b/src/compute/flexbox.rs
@@ -1814,8 +1814,11 @@ fn perform_absolute_layout_on_absolute_children(tree: &mut impl LayoutTree, node
}
let aspect_ratio = child_style.aspect_ratio;
- let margin = child_style.margin.map(|margin| margin.resolve_to_option(container_width));
let align_self = child_style.align_self.unwrap_or(constants.align_items);
+ let margin = child_style.margin.map(|margin| margin.resolve_to_option(container_width));
+ let padding = child_style.padding.resolve_or_zero(Some(container_width));
+ let border = child_style.border.resolve_or_zero(Some(container_width));
+ let padding_border_sum = (padding + border).sum_axes();
// Resolve inset
let left = child_style.inset.left.maybe_resolve(container_width);
@@ -1826,8 +1829,12 @@ fn perform_absolute_layout_on_absolute_children(tree: &mut impl LayoutTree, node
// Compute known dimensions from min/max/inherent size styles
let style_size =
child_style.size.maybe_resolve(constants.container_size).maybe_apply_aspect_ratio(aspect_ratio);
- let min_size =
- child_style.min_size.maybe_resolve(constants.container_size).maybe_apply_aspect_ratio(aspect_ratio);
+ let min_size = child_style
+ .min_size
+ .maybe_resolve(constants.container_size)
+ .maybe_apply_aspect_ratio(aspect_ratio)
+ .or(padding_border_sum.map(Some))
+ .maybe_max(padding_border_sum);
let max_size =
child_style.max_size.maybe_resolve(constants.container_size).maybe_apply_aspect_ratio(aspect_ratio);
let mut known_dimensions = style_size.maybe_clamp(min_size, max_size);
From 77b56d9371cd6163da058c431927369772822d35 Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Sun, 5 Mar 2023 23:46:47 +0000
Subject: [PATCH 12/22] Rename grid padding/border tests so that they are all
located together
---
...grid_padding_border_overrides_container_max_size.html} | 0
... => grid_padding_border_overrides_container_size.html} | 0
...> grid_padding_border_overrides_container_max_size.rs} | 2 +-
...rs => grid_padding_border_overrides_container_size.rs} | 2 +-
tests/generated/mod.rs | 8 ++++----
5 files changed, 6 insertions(+), 6 deletions(-)
rename test_fixtures/{grid_container_padding_border_overrides_max_size.html => grid_padding_border_overrides_container_max_size.html} (100%)
rename test_fixtures/{grid_container_padding_border_overrides_size.html => grid_padding_border_overrides_container_size.html} (100%)
rename tests/generated/{grid_container_padding_border_overrides_max_size.rs => grid_padding_border_overrides_container_max_size.rs} (97%)
rename tests/generated/{grid_container_padding_border_overrides_size.rs => grid_padding_border_overrides_container_size.rs} (98%)
diff --git a/test_fixtures/grid_container_padding_border_overrides_max_size.html b/test_fixtures/grid_padding_border_overrides_container_max_size.html
similarity index 100%
rename from test_fixtures/grid_container_padding_border_overrides_max_size.html
rename to test_fixtures/grid_padding_border_overrides_container_max_size.html
diff --git a/test_fixtures/grid_container_padding_border_overrides_size.html b/test_fixtures/grid_padding_border_overrides_container_size.html
similarity index 100%
rename from test_fixtures/grid_container_padding_border_overrides_size.html
rename to test_fixtures/grid_padding_border_overrides_container_size.html
diff --git a/tests/generated/grid_container_padding_border_overrides_max_size.rs b/tests/generated/grid_padding_border_overrides_container_max_size.rs
similarity index 97%
rename from tests/generated/grid_container_padding_border_overrides_max_size.rs
rename to tests/generated/grid_padding_border_overrides_container_max_size.rs
index dda3d1bc3..62ae9ebbe 100644
--- a/tests/generated/grid_container_padding_border_overrides_max_size.rs
+++ b/tests/generated/grid_padding_border_overrides_container_max_size.rs
@@ -1,5 +1,5 @@
#[test]
-fn grid_container_padding_border_overrides_max_size() {
+fn grid_padding_border_overrides_container_max_size() {
use slotmap::Key;
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
diff --git a/tests/generated/grid_container_padding_border_overrides_size.rs b/tests/generated/grid_padding_border_overrides_container_size.rs
similarity index 98%
rename from tests/generated/grid_container_padding_border_overrides_size.rs
rename to tests/generated/grid_padding_border_overrides_container_size.rs
index 55c1bdd20..f60ea6885 100644
--- a/tests/generated/grid_container_padding_border_overrides_size.rs
+++ b/tests/generated/grid_padding_border_overrides_container_size.rs
@@ -1,5 +1,5 @@
#[test]
-fn grid_container_padding_border_overrides_size() {
+fn grid_padding_border_overrides_container_size() {
use slotmap::Key;
#[allow(unused_imports)]
use taffy::{layout::Layout, prelude::*};
diff --git a/tests/generated/mod.rs b/tests/generated/mod.rs
index f963beca8..79c1ea559 100644
--- a/tests/generated/mod.rs
+++ b/tests/generated/mod.rs
@@ -466,10 +466,6 @@ mod grid_basic_with_overflow;
#[cfg(feature = "grid")]
mod grid_basic_with_padding;
#[cfg(feature = "grid")]
-mod grid_container_padding_border_overrides_max_size;
-#[cfg(feature = "grid")]
-mod grid_container_padding_border_overrides_size;
-#[cfg(feature = "grid")]
mod grid_display_none_fixed_size;
#[cfg(feature = "grid")]
mod grid_fit_content_percent_definite_argument;
@@ -652,6 +648,10 @@ mod grid_out_of_order_items;
#[cfg(feature = "grid")]
mod grid_overflow_rows;
#[cfg(feature = "grid")]
+mod grid_padding_border_overrides_container_max_size;
+#[cfg(feature = "grid")]
+mod grid_padding_border_overrides_container_size;
+#[cfg(feature = "grid")]
mod grid_padding_border_overrides_max_size;
#[cfg(feature = "grid")]
mod grid_padding_border_overrides_min_size;
From 415959e41ab85e6e4cebe97b9876bcd85bf3a64b Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Wed, 8 Mar 2023 21:12:42 +0000
Subject: [PATCH 13/22] Make padding/border floor node size for grid children
---
src/compute/grid/alignment.rs | 13 +++++++++++--
1 file changed, 11 insertions(+), 2 deletions(-)
diff --git a/src/compute/grid/alignment.rs b/src/compute/grid/alignment.rs
index 0c0ed9f81..0b85fb792 100644
--- a/src/compute/grid/alignment.rs
+++ b/src/compute/grid/alignment.rs
@@ -7,7 +7,7 @@ use crate::geometry::{Line, Point, Rect, Size};
use crate::layout::{Layout, SizingMode};
use crate::math::MaybeMath;
use crate::node::Node;
-use crate::resolve::MaybeResolve;
+use crate::resolve::{MaybeResolve, ResolveOrZero};
use crate::style::{AlignContent, AlignItems, AlignSelf, AvailableSpace, Position};
use crate::sys::{f32_max, f32_min};
use crate::tree::LayoutTree;
@@ -90,8 +90,16 @@ pub(super) fn align_and_position_item(
let position = style.position;
let inset_horizontal = style.inset.horizontal_components().map(|size| size.resolve_to_option(grid_area_size.width));
let inset_vertical = style.inset.vertical_components().map(|size| size.resolve_to_option(grid_area_size.height));
+ let padding = style.padding.map(|p| p.resolve_or_zero(Some(grid_area_size.width)));
+ let border = style.border.map(|p| p.resolve_or_zero(Some(grid_area_size.width)));
+ let padding_border_size = (padding + border).sum_axes();
let inherent_size = style.size.maybe_resolve(grid_area_size).maybe_apply_aspect_ratio(aspect_ratio);
- let min_size = style.min_size.maybe_resolve(grid_area_size).maybe_apply_aspect_ratio(aspect_ratio);
+ let min_size = style
+ .min_size
+ .maybe_resolve(grid_area_size)
+ .or(padding_border_size.map(Some))
+ .maybe_max(padding_border_size)
+ .maybe_apply_aspect_ratio(aspect_ratio);
let max_size = style.max_size.maybe_resolve(grid_area_size).maybe_apply_aspect_ratio(aspect_ratio);
// Resolve default alignment styles if they are set on neither the parent or the node itself
@@ -149,6 +157,7 @@ pub(super) fn align_and_position_item(
None
});
+
// Reapply aspect ratio after stretch and absolute position width adjustments
let Size { width, height } = Size { width, height: inherent_size.height }.maybe_apply_aspect_ratio(aspect_ratio);
From b44b3452b875ae05686ad8de6d78b342c6d70e6d Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Wed, 8 Mar 2023 21:18:08 +0000
Subject: [PATCH 14/22] Make padding/border floor node size for grid containers
---
src/compute/grid/mod.rs | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
diff --git a/src/compute/grid/mod.rs b/src/compute/grid/mod.rs
index 10d360068..09a91eb09 100644
--- a/src/compute/grid/mod.rs
+++ b/src/compute/grid/mod.rs
@@ -141,6 +141,7 @@ pub fn compute(
// https://www.w3.org/TR/css-grid-1/#available-grid-space
let padding = style.padding.resolve_or_zero(parent_size.width);
let border = style.border.resolve_or_zero(parent_size.width);
+ let padding_border_size = (padding + border).sum_axes();
let aspect_ratio = style.aspect_ratio;
let min_size = style.min_size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
let max_size = style.max_size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
@@ -236,10 +237,12 @@ pub fn compute(
let container_border_box = Size {
width: resolved_style_size
.get(AbstractAxis::Inline)
- .unwrap_or_else(|| initial_column_sum + padding.horizontal_axis_sum() + border.horizontal_axis_sum()),
+ .unwrap_or_else(|| initial_column_sum + padding.horizontal_axis_sum() + border.horizontal_axis_sum())
+ .max(padding_border_size.width),
height: resolved_style_size
.get(AbstractAxis::Block)
- .unwrap_or_else(|| initial_row_sum + padding.vertical_axis_sum() + border.vertical_axis_sum()),
+ .unwrap_or_else(|| initial_row_sum + padding.vertical_axis_sum() + border.vertical_axis_sum())
+ .max(padding_border_size.height),
};
let container_content_box = Size {
width: container_border_box.width - padding.horizontal_axis_sum() - border.horizontal_axis_sum(),
From c3720058e676d5e7d0ff11d2cbf757fffebc545e Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Wed, 8 Mar 2023 21:46:21 +0000
Subject: [PATCH 15/22] Apply aspect ratio to leaf nodes whose size is
determined by padding/border sum
---
src/compute/leaf.rs | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/src/compute/leaf.rs b/src/compute/leaf.rs
index 5d0a59e8f..2b567ccc4 100644
--- a/src/compute/leaf.rs
+++ b/src/compute/leaf.rs
@@ -141,5 +141,11 @@ pub(crate) fn compute(
.maybe_clamp(node_min_size.height, node_max_size.height)
.maybe_max(padding_border.vertical_axis_sum().into()),
};
+
+ let size = Size {
+ width: f32_max(size.width, aspect_ratio.map(|ratio| size.height * ratio).unwrap_or(0.0)),
+ height: f32_max(size.height, aspect_ratio.map(|ratio| size.width / ratio).unwrap_or(0.0)),
+ };
+
SizeAndBaselines { size, first_baselines: Point::NONE }
}
From b5126681fad277202bef98d4a5ab42d77a298ea0 Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Thu, 9 Mar 2023 12:30:09 +0000
Subject: [PATCH 16/22] Add test for padding/border not affecting flex basis
---
...ding_border_overrides_size_flex_basis.html | 18 ++++++
tests/generated/mod.rs | 1 +
...adding_border_overrides_size_flex_basis.rs | 61 +++++++++++++++++++
3 files changed, 80 insertions(+)
create mode 100644 test_fixtures/padding_border_overrides_size_flex_basis.html
create mode 100644 tests/generated/padding_border_overrides_size_flex_basis.rs
diff --git a/test_fixtures/padding_border_overrides_size_flex_basis.html b/test_fixtures/padding_border_overrides_size_flex_basis.html
new file mode 100644
index 000000000..f34599a1b
--- /dev/null
+++ b/test_fixtures/padding_border_overrides_size_flex_basis.html
@@ -0,0 +1,18 @@
+
+
+
+
+
+
+ Test description
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/generated/mod.rs b/tests/generated/mod.rs
index 79c1ea559..b16b14af0 100644
--- a/tests/generated/mod.rs
+++ b/tests/generated/mod.rs
@@ -838,6 +838,7 @@ mod padding_align_end_child;
mod padding_border_overrides_max_size;
mod padding_border_overrides_min_size;
mod padding_border_overrides_size;
+mod padding_border_overrides_size_flex_basis;
mod padding_center_child;
mod padding_container_match_child;
mod padding_flex_child;
diff --git a/tests/generated/padding_border_overrides_size_flex_basis.rs b/tests/generated/padding_border_overrides_size_flex_basis.rs
new file mode 100644
index 000000000..14e18d5b4
--- /dev/null
+++ b/tests/generated/padding_border_overrides_size_flex_basis.rs
@@ -0,0 +1,61 @@
+#[test]
+fn padding_border_overrides_size_flex_basis() {
+ use slotmap::Key;
+ #[allow(unused_imports)]
+ use taffy::{layout::Layout, prelude::*};
+ let mut taffy = taffy::Taffy::new();
+ let node0 = taffy
+ .new_leaf(taffy::style::Style {
+ flex_grow: 1f32,
+ flex_basis: taffy::style::Dimension::Points(0f32),
+ size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
+ },
+ padding: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(8f32),
+ right: taffy::style::LengthPercentage::Points(4f32),
+ top: taffy::style::LengthPercentage::Points(2f32),
+ bottom: taffy::style::LengthPercentage::Points(6f32),
+ },
+ border: taffy::geometry::Rect {
+ left: taffy::style::LengthPercentage::Points(7f32),
+ right: taffy::style::LengthPercentage::Points(3f32),
+ top: taffy::style::LengthPercentage::Points(1f32),
+ bottom: taffy::style::LengthPercentage::Points(5f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ let node1 = taffy
+ .new_leaf(taffy::style::Style {
+ flex_grow: 1f32,
+ flex_basis: taffy::style::Dimension::Points(0f32),
+ size: taffy::geometry::Size {
+ width: taffy::style::Dimension::Points(12f32),
+ height: taffy::style::Dimension::Points(12f32),
+ },
+ ..Default::default()
+ })
+ .unwrap();
+ let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0, node1]).unwrap();
+ taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+ println!("\nComputed tree:");
+ taffy::debug::print_tree(&taffy, node);
+ println!();
+ let Layout { size, location, .. } = taffy.layout(node).unwrap();
+ assert_eq!(size.width, 34f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 34f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node0).unwrap();
+ assert_eq!(size.width, 28f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 28f32, size.width);
+ assert_eq!(size.height, 14f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 14f32, size.height);
+ assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
+ let Layout { size, location, .. } = taffy.layout(node1).unwrap();
+ assert_eq!(size.width, 6f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 6f32, size.width);
+ assert_eq!(size.height, 12f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 12f32, size.height);
+ assert_eq!(location.x, 28f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 28f32, location.x);
+ assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+}
From 171cdea7b422a5febe334ebfe77c29091b90534e Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Thu, 9 Mar 2023 15:43:32 +0000
Subject: [PATCH 17/22] Convert flex basis determination to use break from
block
---
src/compute/flexbox.rs | 124 ++++++++++++++++++++---------------------
1 file changed, 62 insertions(+), 62 deletions(-)
diff --git a/src/compute/flexbox.rs b/src/compute/flexbox.rs
index 12bf91ddb..eceaf41c8 100644
--- a/src/compute/flexbox.rs
+++ b/src/compute/flexbox.rs
@@ -614,76 +614,76 @@ fn determine_flex_base_size(
for child in flex_items.iter_mut() {
let child_style = tree.style(child.node);
- // A. If the item has a definite used flex basis, that’s the flex base size.
+ child.flex_basis = 'flex_basis: {
+ // A. If the item has a definite used flex basis, that’s the flex base size.
- // B. If the flex item has an intrinsic aspect ratio,
- // a used flex basis of content, and a definite cross size,
- // then the flex base size is calculated from its inner
- // cross size and the flex item’s intrinsic aspect ratio.
+ // B. If the flex item has an intrinsic aspect ratio,
+ // a used flex basis of content, and a definite cross size,
+ // then the flex base size is calculated from its inner
+ // cross size and the flex item’s intrinsic aspect ratio.
- // Note: `child.size` has already been resolved against aspect_ratio in generate_anonymous_flex_items
- // So B will just work here by using main_size without special handling for aspect_ratio
+ // Note: `child.size` has already been resolved against aspect_ratio in generate_anonymous_flex_items
+ // So B will just work here by using main_size without special handling for aspect_ratio
- let flex_basis = child_style.flex_basis.maybe_resolve(constants.node_inner_size.main(constants.dir));
- let main_size = child.size.main(constants.dir);
- if let Some(flex_basis) = flex_basis.or(main_size) {
- child.flex_basis = flex_basis;
- continue;
- };
+ let flex_basis = child_style.flex_basis.maybe_resolve(constants.node_inner_size.main(constants.dir));
+ let main_size = child.size.main(constants.dir);
+ if let Some(flex_basis) = flex_basis.or(main_size) {
+ break 'flex_basis flex_basis;
+ };
- // C. If the used flex basis is content or depends on its available space,
- // and the flex container is being sized under a min-content or max-content
- // constraint (e.g. when performing automatic table layout [CSS21]),
- // size the item under that constraint. The flex base size is the item’s
- // resulting main size.
-
- // This is covered by the implementation of E below, which passes the available_space constraint
- // through to the child size computation. It may need a separate implementation if/when D is implemented.
-
- // D. Otherwise, if the used flex basis is content or depends on its
- // available space, the available main size is infinite, and the flex item’s
- // inline axis is parallel to the main axis, lay the item out using the rules
- // for a box in an orthogonal flow [CSS3-WRITING-MODES]. The flex base size
- // is the item’s max-content main size.
-
- // TODO if/when vertical writing modes are supported
-
- // E. Otherwise, size the item into the available space using its used flex basis
- // in place of its main size, treating a value of content as max-content.
- // If a cross size is needed to determine the main size (e.g. when the
- // flex item’s main size is in its block axis) and the flex item’s cross size
- // is auto and not definite, in this calculation use fit-content as the
- // flex item’s cross size. The flex base size is the item’s resulting main size.
-
- let child_known_dimensions = {
- let mut ckd = child.size;
- if child.align_self == AlignSelf::Stretch && ckd.cross(constants.dir).is_none() {
- ckd.set_cross(
- constants.dir,
- available_space
- .cross(constants.dir)
- .into_option()
- .maybe_sub(constants.margin.cross_axis_sum(constants.dir)),
- );
- }
- ckd
+ // C. If the used flex basis is content or depends on its available space,
+ // and the flex container is being sized under a min-content or max-content
+ // constraint (e.g. when performing automatic table layout [CSS21]),
+ // size the item under that constraint. The flex base size is the item’s
+ // resulting main size.
+
+ // This is covered by the implementation of E below, which passes the available_space constraint
+ // through to the child size computation. It may need a separate implementation if/when D is implemented.
+
+ // D. Otherwise, if the used flex basis is content or depends on its
+ // available space, the available main size is infinite, and the flex item’s
+ // inline axis is parallel to the main axis, lay the item out using the rules
+ // for a box in an orthogonal flow [CSS3-WRITING-MODES]. The flex base size
+ // is the item’s max-content main size.
+
+ // TODO if/when vertical writing modes are supported
+
+ // E. Otherwise, size the item into the available space using its used flex basis
+ // in place of its main size, treating a value of content as max-content.
+ // If a cross size is needed to determine the main size (e.g. when the
+ // flex item’s main size is in its block axis) and the flex item’s cross size
+ // is auto and not definite, in this calculation use fit-content as the
+ // flex item’s cross size. The flex base size is the item’s resulting main size.
+
+ let child_known_dimensions = {
+ let mut ckd = child.size;
+ if child.align_self == AlignSelf::Stretch && ckd.cross(constants.dir).is_none() {
+ ckd.set_cross(
+ constants.dir,
+ available_space
+ .cross(constants.dir)
+ .into_option()
+ .maybe_sub(constants.margin.cross_axis_sum(constants.dir)),
+ );
+ }
+ ckd
+ };
+
+ break 'flex_basis GenericAlgorithm::measure_size(
+ tree,
+ child.node,
+ child_known_dimensions,
+ constants.node_inner_size,
+ available_space,
+ SizingMode::ContentSize,
+ )
+ .main(constants.dir);
};
- child.flex_basis = GenericAlgorithm::measure_size(
- tree,
- child.node,
- child_known_dimensions,
- constants.node_inner_size,
- available_space,
- SizingMode::ContentSize,
- )
- .main(constants.dir);
- }
- // The hypothetical main size is the item’s flex base size clamped according to its
- // used min and max main sizes (and flooring the content box size at zero).
+ // The hypothetical main size is the item’s flex base size clamped according to its
+ // used min and max main sizes (and flooring the content box size at zero).
- for child in flex_items {
child.inner_flex_basis =
child.flex_basis - child.padding.main_axis_sum(constants.dir) - child.border.main_axis_sum(constants.dir);
From cb6c40129c78052d3b4a393c8f9d1c1ab38e7fcc Mon Sep 17 00:00:00 2001
From: Nico Burns
Date: Thu, 9 Mar 2023 15:58:42 +0000
Subject: [PATCH 18/22] Add test for flex-basis 0 with flex grow
---
...g_border_overrides_size_flex_basis_0.html} | 4 +-
..._overrides_size_flex_basis_0_growable.html | 18 ++++++
tests/generated/mod.rs | 3 +-
...ding_border_overrides_size_flex_basis_0.rs | 59 +++++++++++++++++++
...r_overrides_size_flex_basis_0_growable.rs} | 2 +-
5 files changed, 82 insertions(+), 4 deletions(-)
rename test_fixtures/{padding_border_overrides_size_flex_basis.html => padding_border_overrides_size_flex_basis_0.html} (54%)
create mode 100644 test_fixtures/padding_border_overrides_size_flex_basis_0_growable.html
create mode 100644 tests/generated/padding_border_overrides_size_flex_basis_0.rs
rename tests/generated/{padding_border_overrides_size_flex_basis.rs => padding_border_overrides_size_flex_basis_0_growable.rs} (98%)
diff --git a/test_fixtures/padding_border_overrides_size_flex_basis.html b/test_fixtures/padding_border_overrides_size_flex_basis_0.html
similarity index 54%
rename from test_fixtures/padding_border_overrides_size_flex_basis.html
rename to test_fixtures/padding_border_overrides_size_flex_basis_0.html
index f34599a1b..d51e820ce 100644
--- a/test_fixtures/padding_border_overrides_size_flex_basis.html
+++ b/test_fixtures/padding_border_overrides_size_flex_basis_0.html
@@ -10,8 +10,8 @@