tawasuyu/taffy

* Add script to diff taffy tests against yoga tests by name

* Add fixture template

* Modify diff script to display disabled tests next to enabled ones

* Make diff script work using environment variable

* Add script to import test fixtures from yoga

* Fix diff script for column_row_gap test

* Remove commented code

* Add cargo command for importing yoga tests

* Import all generated tests from yoga (failing tests disabled)

* Import tests with explicit flex direction

* Convert tests not specifically testing start/end to use left/right instead

* Replace margin-start with margin-left in android_news_feed tests

* Document convention of tests starting with an x being disabled

* Enable absolute child with margin tests

* Fix align content not stretch with align items stretch

* Add README for import-yoga-tests package

* Remove broken after chrome behaviour change comment

diff --git a/.cargo/config.toml b/.cargo/config.toml
index 52ecae305..703f9e005 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,2 +1,3 @@
 [alias]
-gentest = "run --release --package gentest --"
\ No newline at end of file
+gentest = "run --release --package gentest --"
+import-yoga-tests = "run --package import-yoga-tests --"
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index f618073f8..e37b738c2 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -36,6 +36,8 @@ Once you have chromedriver installed and available in `PATH` you can re-generate
 
 To add a new test case add another HTML file to `/test_fixtures` following the current tests as a template for new tests.
 
+**Note: test fixtures (HTML files in the `text_fixtures` directory) that begin with an "x" are considered disabled, and the test generation script will not generate a test for them (and as the test generation script overwrites the entire directory when generating tests, this means that prefixing an existing test with an "x" and then running the test generation script will delete that test)**
+
 ### Writing tests
 
 1. All tests should be wrapped in a module called `tests` gated by the standard `test` feature flag, to ensure they are not compiled unless tests are being run.
diff --git a/Cargo.toml b/Cargo.toml
index d48c5ae06..2bc0121c8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -59,4 +59,4 @@ path = "benches/big_tree.rs"
 harness = false
 
 [workspace]
-members = ["scripts/gentest"]
+members = ["scripts/gentest", "scripts/import-yoga-tests"]
diff --git a/benches/generated/absolute_child_with_cross_margin.rs b/benches/generated/absolute_child_with_cross_margin.rs
new file mode 100644
index 000000000..4e0082611
--- /dev/null
+++ b/benches/generated/absolute_child_with_cross_margin.rs
@@ -0,0 +1,74 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(28f32),
+                height: taffy::style::Dimension::Points(27f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf_with_measure(
+            taffy::style::Style {
+                position: taffy::style::Position::Absolute,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                flex_grow: 0f32,
+                flex_shrink: 1f32,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Percent(1f32),
+                    height: taffy::style::Dimension::Points(15f32),
+                },
+                margin: taffy::geometry::Rect {
+                    left: zero(),
+                    right: zero(),
+                    top: taffy::style::LengthPercentageAuto::Points(4f32),
+                    bottom: zero(),
+                },
+                ..Default::default()
+            },
+            taffy::node::MeasureFunc::Raw(|known_dimensions, available_space| {
+                const TEXT: &str = "\n  ";
+                super::measure_standard_text(
+                    known_dimensions,
+                    available_space,
+                    TEXT,
+                    super::WritingMode::Horizontal,
+                    None,
+                )
+            }),
+        )
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(25f32),
+                height: taffy::style::Dimension::Points(27f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                justify_content: Some(taffy::style::JustifyContent::SpaceBetween),
+                min_size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(311f32),
+                    height: taffy::style::Dimension::Points(0f32),
+                },
+                max_size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(311f32),
+                    height: taffy::style::Dimension::Points(36893500000000000000f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/absolute_child_with_main_margin.rs b/benches/generated/absolute_child_with_main_margin.rs
new file mode 100644
index 000000000..572374029
--- /dev/null
+++ b/benches/generated/absolute_child_with_main_margin.rs
@@ -0,0 +1,34 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::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(9f32),
+                height: taffy::style::Dimension::Points(9f32),
+            },
+            margin: taffy::geometry::Rect {
+                left: taffy::style::LengthPercentageAuto::Points(7f32),
+                right: zero(),
+                top: zero(),
+                bottom: zero(),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(20f32),
+                    height: taffy::style::Dimension::Points(37f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/absolute_child_with_max_height.rs b/benches/generated/absolute_child_with_max_height.rs
new file mode 100644
index 000000000..d85bdd9ad
--- /dev/null
+++ b/benches/generated/absolute_child_with_max_height.rs
@@ -0,0 +1,45 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(100f32),
+                height: taffy::style::Dimension::Points(30f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                position: taffy::style::Position::Absolute,
+                flex_direction: taffy::style::FlexDirection::Column,
+                max_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(100f32) },
+                inset: taffy::geometry::Rect {
+                    left: auto(),
+                    right: auto(),
+                    top: auto(),
+                    bottom: taffy::style::LengthPercentageAuto::Points(20f32),
+                },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(200f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/absolute_child_with_max_height_larger_shrinkable_grandchild.rs b/benches/generated/absolute_child_with_max_height_larger_shrinkable_grandchild.rs
new file mode 100644
index 000000000..0b46b234c
--- /dev/null
+++ b/benches/generated/absolute_child_with_max_height_larger_shrinkable_grandchild.rs
@@ -0,0 +1,44 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Points(150f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(100f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                position: taffy::style::Position::Absolute,
+                flex_direction: taffy::style::FlexDirection::Column,
+                max_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(100f32) },
+                inset: taffy::geometry::Rect {
+                    left: auto(),
+                    right: auto(),
+                    top: auto(),
+                    bottom: taffy::style::LengthPercentageAuto::Points(20f32),
+                },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(200f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/absolute_layout_percentage_height.rs b/benches/generated/absolute_layout_percentage_height.rs
new file mode 100644
index 000000000..726e8ef33
--- /dev/null
+++ b/benches/generated/absolute_layout_percentage_height.rs
@@ -0,0 +1,34 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::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(10f32),
+                height: taffy::style::Dimension::Percent(0.5f32),
+            },
+            inset: taffy::geometry::Rect {
+                left: taffy::style::LengthPercentageAuto::Points(10f32),
+                right: auto(),
+                top: taffy::style::LengthPercentageAuto::Points(10f32),
+                bottom: auto(),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(200f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/absolute_layout_row_width_height_end_bottom.rs b/benches/generated/absolute_layout_row_width_height_end_bottom.rs
new file mode 100644
index 000000000..d23fd5800
--- /dev/null
+++ b/benches/generated/absolute_layout_row_width_height_end_bottom.rs
@@ -0,0 +1,34 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::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(10f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            inset: taffy::geometry::Rect {
+                left: auto(),
+                right: taffy::style::LengthPercentageAuto::Points(10f32),
+                top: auto(),
+                bottom: taffy::style::LengthPercentageAuto::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_baseline_child.rs b/benches/generated/align_baseline_child.rs
new file mode 100644
index 000000000..f8e870c7e
--- /dev/null
+++ b/benches/generated/align_baseline_child.rs
@@ -0,0 +1,50 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(20f32),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_baseline_child_top.rs b/benches/generated/align_baseline_child_top.rs
new file mode 100644
index 000000000..24c4ccf8d
--- /dev/null
+++ b/benches/generated/align_baseline_child_top.rs
@@ -0,0 +1,56 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            inset: taffy::geometry::Rect {
+                left: auto(),
+                right: auto(),
+                top: taffy::style::LengthPercentageAuto::Points(10f32),
+                bottom: auto(),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(20f32),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_baseline_child_top2.rs b/benches/generated/align_baseline_child_top2.rs
new file mode 100644
index 000000000..af3cb50bc
--- /dev/null
+++ b/benches/generated/align_baseline_child_top2.rs
@@ -0,0 +1,55 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(20f32),
+                },
+                inset: taffy::geometry::Rect {
+                    left: auto(),
+                    right: auto(),
+                    top: taffy::style::LengthPercentageAuto::Points(5f32),
+                    bottom: auto(),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_baseline_column.rs b/benches/generated/align_baseline_column.rs
new file mode 100644
index 000000000..76b66d798
--- /dev/null
+++ b/benches/generated/align_baseline_column.rs
@@ -0,0 +1,38 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_baseline_double_nested_child.rs b/benches/generated/align_baseline_double_nested_child.rs
new file mode 100644
index 000000000..3f0116a0c
--- /dev/null
+++ b/benches/generated/align_baseline_double_nested_child.rs
@@ -0,0 +1,61 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(50f32),
+                },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(15f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(20f32),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_baseline_multiline_column.rs b/benches/generated/align_baseline_multiline_column.rs
new file mode 100644
index 000000000..fcb32073b
--- /dev/null
+++ b/benches/generated/align_baseline_multiline_column.rs
@@ -0,0 +1,83 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(30f32),
+                    height: taffy::style::Dimension::Points(50f32),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node20 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(10f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(40f32),
+                    height: taffy::style::Dimension::Points(70f32),
+                },
+                ..Default::default()
+            },
+            &[node20],
+        )
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_baseline_multiline_column2.rs b/benches/generated/align_baseline_multiline_column2.rs
new file mode 100644
index 000000000..269fcaded
--- /dev/null
+++ b/benches/generated/align_baseline_multiline_column2.rs
@@ -0,0 +1,87 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(30f32),
+                    height: taffy::style::Dimension::Points(50f32),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node20 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(10f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(40f32),
+                    height: taffy::style::Dimension::Points(70f32),
+                },
+                ..Default::default()
+            },
+            &[node20],
+        )
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_baseline_nested_column.rs b/benches/generated/align_baseline_nested_column.rs
new file mode 100644
index 000000000..8f556c9cb
--- /dev/null
+++ b/benches/generated/align_baseline_nested_column.rs
@@ -0,0 +1,67 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(60f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node100 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(30f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node101 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(40f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(80f32),
+                },
+                ..Default::default()
+            },
+            &[node100, node101],
+        )
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style { flex_direction: taffy::style::FlexDirection::Column, ..Default::default() },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_flex_end.rs b/benches/generated/align_content_flex_end.rs
new file mode 100644
index 000000000..1890612d4
--- /dev/null
+++ b/benches/generated/align_content_flex_end.rs
@@ -0,0 +1,66 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::End),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_flex_start.rs b/benches/generated/align_content_flex_start.rs
new file mode 100644
index 000000000..51979c0bc
--- /dev/null
+++ b/benches/generated/align_content_flex_start.rs
@@ -0,0 +1,65 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Start),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(130f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_flex_start_with_flex.rs b/benches/generated/align_content_flex_start_with_flex.rs
new file mode 100644
index 000000000..0cd171fef
--- /dev/null
+++ b/benches/generated/align_content_flex_start_with_flex.rs
@@ -0,0 +1,63 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 0f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 0f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Start),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(120f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_flex_start_without_height_on_children.rs b/benches/generated/align_content_flex_start_without_height_on_children.rs
new file mode 100644
index 000000000..2b2671ad8
--- /dev/null
+++ b/benches/generated/align_content_flex_start_without_height_on_children.rs
@@ -0,0 +1,57 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Start),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_not_stretch_with_align_items_stretch.rs b/benches/generated/align_content_not_stretch_with_align_items_stretch.rs
new file mode 100644
index 000000000..568dab8b4
--- /dev/null
+++ b/benches/generated/align_content_not_stretch_with_align_items_stretch.rs
@@ -0,0 +1,50 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(272f32),
+                height: taffy::style::Dimension::Points(44f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style { flex_direction: taffy::style::FlexDirection::Column, ..Default::default() },
+            &[node00],
+        )
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(56f32),
+                height: taffy::style::Dimension::Points(44f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style { flex_direction: taffy::style::FlexDirection::Column, ..Default::default() },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Start),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(328f32),
+                    height: taffy::style::Dimension::Points(52f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_spacearound.rs b/benches/generated/align_content_spacearound.rs
new file mode 100644
index 000000000..6e0ca4653
--- /dev/null
+++ b/benches/generated/align_content_spacearound.rs
@@ -0,0 +1,65 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::SpaceAround),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(140f32),
+                    height: taffy::style::Dimension::Points(120f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_spacebetween.rs b/benches/generated/align_content_spacebetween.rs
new file mode 100644
index 000000000..986e32fa3
--- /dev/null
+++ b/benches/generated/align_content_spacebetween.rs
@@ -0,0 +1,65 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::SpaceBetween),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(130f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch.rs b/benches/generated/align_content_stretch.rs
new file mode 100644
index 000000000..760e8a04c
--- /dev/null
+++ b/benches/generated/align_content_stretch.rs
@@ -0,0 +1,51 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_column.rs b/benches/generated/align_content_stretch_column.rs
new file mode 100644
index 000000000..1cb9af7d7
--- /dev/null
+++ b/benches/generated/align_content_stretch_column.rs
@@ -0,0 +1,66 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(150f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_is_not_overriding_align_items.rs b/benches/generated/align_content_stretch_is_not_overriding_align_items.rs
new file mode 100644
index 000000000..19b8589e9
--- /dev/null
+++ b/benches/generated/align_content_stretch_is_not_overriding_align_items.rs
@@ -0,0 +1,36 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(10f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Center),
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style { align_content: Some(taffy::style::AlignContent::Stretch), ..Default::default() },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_row.rs b/benches/generated/align_content_stretch_row.rs
new file mode 100644
index 000000000..7d56cef19
--- /dev/null
+++ b/benches/generated/align_content_stretch_row.rs
@@ -0,0 +1,50 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_row_with_children.rs b/benches/generated/align_content_stretch_row_with_children.rs
new file mode 100644
index 000000000..accdcc012
--- /dev/null
+++ b/benches/generated/align_content_stretch_row_with_children.rs
@@ -0,0 +1,62 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_row_with_fixed_height.rs b/benches/generated/align_content_stretch_row_with_fixed_height.rs
new file mode 100644
index 000000000..7048feb09
--- /dev/null
+++ b/benches/generated/align_content_stretch_row_with_fixed_height.rs
@@ -0,0 +1,53 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(60f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_row_with_flex.rs b/benches/generated/align_content_stretch_row_with_flex.rs
new file mode 100644
index 000000000..3015b753f
--- /dev/null
+++ b/benches/generated/align_content_stretch_row_with_flex.rs
@@ -0,0 +1,56 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_row_with_flex_no_shrink.rs b/benches/generated/align_content_stretch_row_with_flex_no_shrink.rs
new file mode 100644
index 000000000..ec2152fc3
--- /dev/null
+++ b/benches/generated/align_content_stretch_row_with_flex_no_shrink.rs
@@ -0,0 +1,56 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 0f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_row_with_margin.rs b/benches/generated/align_content_stretch_row_with_margin.rs
new file mode 100644
index 000000000..eb0cfc83d
--- /dev/null
+++ b/benches/generated/align_content_stretch_row_with_margin.rs
@@ -0,0 +1,62 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            margin: taffy::geometry::Rect {
+                left: taffy::style::LengthPercentageAuto::Points(10f32),
+                right: taffy::style::LengthPercentageAuto::Points(10f32),
+                top: taffy::style::LengthPercentageAuto::Points(10f32),
+                bottom: taffy::style::LengthPercentageAuto::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            margin: taffy::geometry::Rect {
+                left: taffy::style::LengthPercentageAuto::Points(10f32),
+                right: taffy::style::LengthPercentageAuto::Points(10f32),
+                top: taffy::style::LengthPercentageAuto::Points(10f32),
+                bottom: taffy::style::LengthPercentageAuto::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_row_with_max_height.rs b/benches/generated/align_content_stretch_row_with_max_height.rs
new file mode 100644
index 000000000..8c6f61839
--- /dev/null
+++ b/benches/generated/align_content_stretch_row_with_max_height.rs
@@ -0,0 +1,51 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            max_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(20f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_row_with_min_height.rs b/benches/generated/align_content_stretch_row_with_min_height.rs
new file mode 100644
index 000000000..fc27640f1
--- /dev/null
+++ b/benches/generated/align_content_stretch_row_with_min_height.rs
@@ -0,0 +1,51 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            min_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(80f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_row_with_padding.rs b/benches/generated/align_content_stretch_row_with_padding.rs
new file mode 100644
index 000000000..a48b8ed2b
--- /dev/null
+++ b/benches/generated/align_content_stretch_row_with_padding.rs
@@ -0,0 +1,62 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            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();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            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();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_content_stretch_row_with_single_row.rs b/benches/generated/align_content_stretch_row_with_single_row.rs
new file mode 100644
index 000000000..59b03b418
--- /dev/null
+++ b/benches/generated/align_content_stretch_row_with_single_row.rs
@@ -0,0 +1,32 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_items_center_justify_content_center.rs b/benches/generated/align_items_center_justify_content_center.rs
new file mode 100644
index 000000000..ecb43aa10
--- /dev/null
+++ b/benches/generated/align_items_center_justify_content_center.rs
@@ -0,0 +1,70 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node000 = taffy
+        .new_leaf_with_measure(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(10f32),
+                    height: taffy::style::Dimension::Points(10f32),
+                },
+                ..Default::default()
+            },
+            taffy::node::MeasureFunc::Raw(|known_dimensions, available_space| {
+                const TEXT: &str = "\n      ";
+                super::measure_standard_text(
+                    known_dimensions,
+                    available_space,
+                    TEXT,
+                    super::WritingMode::Horizontal,
+                    None,
+                )
+            }),
+        )
+        .unwrap();
+    let node00 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_items: Some(taffy::style::AlignItems::Center),
+                justify_content: Some(taffy::style::JustifyContent::Center),
+                size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Percent(1f32) },
+                margin: taffy::geometry::Rect {
+                    left: taffy::style::LengthPercentageAuto::Points(10f32),
+                    right: taffy::style::LengthPercentageAuto::Points(10f32),
+                    top: zero(),
+                    bottom: zero(),
+                },
+                ..Default::default()
+            },
+            &[node000],
+        )
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_items: Some(taffy::style::AlignItems::Center),
+                justify_content: Some(taffy::style::JustifyContent::Center),
+                size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(500f32),
+                    height: taffy::style::Dimension::Points(500f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_items_center_min_max_with_padding.rs b/benches/generated/align_items_center_min_max_with_padding.rs
new file mode 100644
index 000000000..f5047f587
--- /dev/null
+++ b/benches/generated/align_items_center_min_max_with_padding.rs
@@ -0,0 +1,38 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(62f32),
+                height: taffy::style::Dimension::Points(62f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Center),
+                min_size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(320f32),
+                    height: taffy::style::Dimension::Points(72f32),
+                },
+                max_size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(320f32),
+                    height: taffy::style::Dimension::Points(504f32),
+                },
+                padding: taffy::geometry::Rect {
+                    left: zero(),
+                    right: zero(),
+                    top: taffy::style::LengthPercentage::Points(8f32),
+                    bottom: taffy::style::LengthPercentage::Points(8f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_items_stretch_min_cross.rs b/benches/generated/align_items_stretch_min_cross.rs
new file mode 100644
index 000000000..9c142701e
--- /dev/null
+++ b/benches/generated/align_items_stretch_min_cross.rs
@@ -0,0 +1,26 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_shrink: 0f32,
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(36f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                min_size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(400f32),
+                    height: taffy::style::Dimension::Points(50f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/align_self_center_undefined_max_height.rs b/benches/generated/align_self_center_undefined_max_height.rs
new file mode 100644
index 000000000..5973a425c
--- /dev/null
+++ b/benches/generated/align_self_center_undefined_max_height.rs
@@ -0,0 +1,35 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(240f32),
+                height: taffy::style::Dimension::Points(44f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            align_self: Some(taffy::style::AlignSelf::Center),
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(40f32),
+                height: taffy::style::Dimension::Points(56f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(280f32), height: auto() },
+                min_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(52f32) },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/android_news_feed.rs b/benches/generated/android_news_feed.rs
new file mode 100644
index 000000000..b551bd59d
--- /dev/null
+++ b/benches/generated/android_news_feed.rs
@@ -0,0 +1,206 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node000000 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            flex_shrink: 0f32,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(120f32),
+                height: taffy::style::Dimension::Points(120f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node00000 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                flex_shrink: 0f32,
+                ..Default::default()
+            },
+            &[node000000],
+        )
+        .unwrap();
+    let node000010 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            flex_shrink: 1f32,
+            ..Default::default()
+        })
+        .unwrap();
+    let node000011 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            flex_shrink: 1f32,
+            ..Default::default()
+        })
+        .unwrap();
+    let node00001 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                flex_shrink: 1f32,
+                margin: taffy::geometry::Rect {
+                    left: zero(),
+                    right: taffy::style::LengthPercentageAuto::Points(36f32),
+                    top: zero(),
+                    bottom: zero(),
+                },
+                padding: taffy::geometry::Rect {
+                    left: taffy::style::LengthPercentage::Points(36f32),
+                    right: taffy::style::LengthPercentage::Points(36f32),
+                    top: taffy::style::LengthPercentage::Points(21f32),
+                    bottom: taffy::style::LengthPercentage::Points(18f32),
+                },
+                ..Default::default()
+            },
+            &[node000010, node000011],
+        )
+        .unwrap();
+    let node0000 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Start),
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                margin: taffy::geometry::Rect {
+                    left: taffy::style::LengthPercentageAuto::Points(36f32),
+                    right: zero(),
+                    top: taffy::style::LengthPercentageAuto::Points(24f32),
+                    bottom: zero(),
+                },
+                ..Default::default()
+            },
+            &[node00000, node00001],
+        )
+        .unwrap();
+    let node000 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                ..Default::default()
+            },
+            &[node0000],
+        )
+        .unwrap();
+    let node001000 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            flex_shrink: 0f32,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(72f32),
+                height: taffy::style::Dimension::Points(72f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node00100 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                flex_shrink: 0f32,
+                ..Default::default()
+            },
+            &[node001000],
+        )
+        .unwrap();
+    let node001010 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            flex_shrink: 1f32,
+            ..Default::default()
+        })
+        .unwrap();
+    let node001011 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            flex_shrink: 1f32,
+            ..Default::default()
+        })
+        .unwrap();
+    let node00101 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                flex_shrink: 1f32,
+                margin: taffy::geometry::Rect {
+                    left: zero(),
+                    right: taffy::style::LengthPercentageAuto::Points(36f32),
+                    top: zero(),
+                    bottom: zero(),
+                },
+                padding: taffy::geometry::Rect {
+                    left: taffy::style::LengthPercentage::Points(36f32),
+                    right: taffy::style::LengthPercentage::Points(36f32),
+                    top: taffy::style::LengthPercentage::Points(21f32),
+                    bottom: taffy::style::LengthPercentage::Points(18f32),
+                },
+                ..Default::default()
+            },
+            &[node001010, node001011],
+        )
+        .unwrap();
+    let node0010 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Start),
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                margin: taffy::geometry::Rect {
+                    left: taffy::style::LengthPercentageAuto::Points(174f32),
+                    right: zero(),
+                    top: taffy::style::LengthPercentageAuto::Points(24f32),
+                    bottom: zero(),
+                },
+                ..Default::default()
+            },
+            &[node00100, node00101],
+        )
+        .unwrap();
+    let node001 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                ..Default::default()
+            },
+            &[node0010],
+        )
+        .unwrap();
+    let node00 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                ..Default::default()
+            },
+            &[node000, node001],
+        )
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_shrink: 0f32,
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                flex_shrink: 0f32,
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(1080f32), height: auto() },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/border_container_match_child.rs b/benches/generated/border_container_match_child.rs
new file mode 100644
index 000000000..5ba9e9313
--- /dev/null
+++ b/benches/generated/border_container_match_child.rs
@@ -0,0 +1,30 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(10f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                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()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/border_no_size.rs b/benches/generated/border_no_size.rs
new file mode 100644
index 000000000..102d4956f
--- /dev/null
+++ b/benches/generated/border_no_size.rs
@@ -0,0 +1,18 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            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();
+}
diff --git a/benches/generated/child_with_padding_align_end.rs b/benches/generated/child_with_padding_align_end.rs
new file mode 100644
index 000000000..b94d7b711
--- /dev/null
+++ b/benches/generated/child_with_padding_align_end.rs
@@ -0,0 +1,36 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(100f32),
+                height: taffy::style::Dimension::Points(100f32),
+            },
+            padding: taffy::geometry::Rect {
+                left: taffy::style::LengthPercentage::Points(20f32),
+                right: taffy::style::LengthPercentage::Points(20f32),
+                top: taffy::style::LengthPercentage::Points(20f32),
+                bottom: taffy::style::LengthPercentage::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_items: Some(taffy::style::AlignItems::End),
+                justify_content: Some(taffy::style::JustifyContent::End),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(200f32),
+                    height: taffy::style::Dimension::Points(200f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/flex_basis_zero_undefined_main_size.rs b/benches/generated/flex_basis_zero_undefined_main_size.rs
new file mode 100644
index 000000000..34f7e0d73
--- /dev/null
+++ b/benches/generated/flex_basis_zero_undefined_main_size.rs
@@ -0,0 +1,26 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(100f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_basis: taffy::style::Dimension::Points(0f32),
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/flex_direction_column_reverse_no_height.rs b/benches/generated/flex_direction_column_reverse_no_height.rs
new file mode 100644
index 000000000..220369733
--- /dev/null
+++ b/benches/generated/flex_direction_column_reverse_no_height.rs
@@ -0,0 +1,34 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(10f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(10f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(10f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::ColumnReverse,
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(100f32), height: auto() },
+                ..Default::default()
+            },
+            &[node0, node1, node2],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/gap_column_gap_row_gap_wrapping.rs b/benches/generated/gap_column_gap_row_gap_wrapping.rs
new file mode 100644
index 000000000..62845199f
--- /dev/null
+++ b/benches/generated/gap_column_gap_row_gap_wrapping.rs
@@ -0,0 +1,101 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node5 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node6 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node7 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node8 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                gap: taffy::geometry::Size {
+                    width: taffy::style::LengthPercentage::Points(10f32),
+                    height: taffy::style::LengthPercentage::Points(20f32),
+                },
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(80f32), height: auto() },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4, node5, node6, node7, node8],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/min_height_larger_than_height.rs b/benches/generated/min_height_larger_than_height.rs
new file mode 100644
index 000000000..b64ee8f10
--- /dev/null
+++ b/benches/generated/min_height_larger_than_height.rs
@@ -0,0 +1,25 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(25f32) },
+            min_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/min_height_with_nested_fixed_height.rs b/benches/generated/min_height_with_nested_fixed_height.rs
new file mode 100644
index 000000000..d04ba7bb0
--- /dev/null
+++ b/benches/generated/min_height_with_nested_fixed_height.rs
@@ -0,0 +1,49 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(40f32),
+                height: taffy::style::Dimension::Points(40f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_self: Some(taffy::style::AlignSelf::Start),
+                flex_shrink: 0f32,
+                min_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(28f32) },
+                margin: taffy::geometry::Rect {
+                    left: zero(),
+                    right: zero(),
+                    top: taffy::style::LengthPercentageAuto::Points(8f32),
+                    bottom: taffy::style::LengthPercentageAuto::Points(9f32),
+                },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(320f32), height: auto() },
+                min_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(44f32) },
+                padding: taffy::geometry::Rect {
+                    left: taffy::style::LengthPercentage::Points(16f32),
+                    right: taffy::style::LengthPercentage::Points(16f32),
+                    top: zero(),
+                    bottom: zero(),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/min_max_percent_different_width_height.rs b/benches/generated/min_max_percent_different_width_height.rs
new file mode 100644
index 000000000..a0e7b48e0
--- /dev/null
+++ b/benches/generated/min_max_percent_different_width_height.rs
@@ -0,0 +1,45 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf_with_measure(
+            taffy::style::Style {
+                min_size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Percent(0.1f32),
+                    height: taffy::style::Dimension::Percent(0.1f32),
+                },
+                max_size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Percent(0.1f32),
+                    height: taffy::style::Dimension::Percent(0.1f32),
+                },
+                ..Default::default()
+            },
+            taffy::node::MeasureFunc::Raw(|known_dimensions, available_space| {
+                const TEXT: &str = "\n  ";
+                super::measure_standard_text(
+                    known_dimensions,
+                    available_space,
+                    TEXT,
+                    super::WritingMode::Horizontal,
+                    None,
+                )
+            }),
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_items: Some(taffy::style::AlignItems::Start),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(200f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/min_width_larger_than_width.rs b/benches/generated/min_width_larger_than_width.rs
new file mode 100644
index 000000000..53c662f8c
--- /dev/null
+++ b/benches/generated/min_width_larger_than_width.rs
@@ -0,0 +1,26 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(25f32), height: auto() },
+            min_size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/mod.rs b/benches/generated/mod.rs
index 14b307b64..33a6c0582 100644
--- a/benches/generated/mod.rs
+++ b/benches/generated/mod.rs
@@ -72,6 +72,10 @@ mod absolute_aspect_ratio_fill_width;
 mod absolute_aspect_ratio_fill_width_from_inset;
 mod absolute_aspect_ratio_height_overrides_inset;
 mod absolute_aspect_ratio_width_overrides_inset;
+mod absolute_child_with_cross_margin;
+mod absolute_child_with_main_margin;
+mod absolute_child_with_max_height;
+mod absolute_child_with_max_height_larger_shrinkable_grandchild;
 mod absolute_layout_align_items_and_justify_content_center;
 mod absolute_layout_align_items_and_justify_content_center_and_bottom_position;
 mod absolute_layout_align_items_and_justify_content_center_and_left_position;
@@ -88,6 +92,8 @@ mod absolute_layout_in_wrap_reverse_row_container_flex_end;
 mod absolute_layout_justify_content_center;
 mod absolute_layout_no_size;
 mod absolute_layout_percentage_bottom_based_on_parent_height;
+mod absolute_layout_percentage_height;
+mod absolute_layout_row_width_height_end_bottom;
 mod absolute_layout_start_top_end_bottom;
 mod absolute_layout_width_height_end_bottom;
 mod absolute_layout_width_height_start_top;
@@ -100,21 +106,51 @@ 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 align_baseline;
+mod align_baseline_child;
 mod align_baseline_child_multiline;
+mod align_baseline_child_top;
+mod align_baseline_child_top2;
+mod align_baseline_column;
+mod align_baseline_double_nested_child;
+mod align_baseline_multiline_column;
+mod align_baseline_multiline_column2;
 mod align_baseline_nested_child;
+mod align_baseline_nested_column;
 mod align_center_should_size_based_on_content;
+mod align_content_flex_end;
+mod align_content_flex_start;
+mod align_content_flex_start_with_flex;
+mod align_content_flex_start_without_height_on_children;
+mod align_content_not_stretch_with_align_items_stretch;
 mod align_content_space_around_single_line;
 mod align_content_space_around_wrapped;
 mod align_content_space_between_single_line;
 mod align_content_space_between_wrapped;
 mod align_content_space_evenly_single_line;
 mod align_content_space_evenly_wrapped;
+mod align_content_spacearound;
+mod align_content_spacebetween;
+mod align_content_stretch;
+mod align_content_stretch_column;
+mod align_content_stretch_is_not_overriding_align_items;
+mod align_content_stretch_row;
+mod align_content_stretch_row_with_children;
+mod align_content_stretch_row_with_fixed_height;
+mod align_content_stretch_row_with_flex;
+mod align_content_stretch_row_with_flex_no_shrink;
+mod align_content_stretch_row_with_margin;
+mod align_content_stretch_row_with_max_height;
+mod align_content_stretch_row_with_min_height;
+mod align_content_stretch_row_with_padding;
+mod align_content_stretch_row_with_single_row;
 mod align_flex_start_with_shrinking_children;
 mod align_flex_start_with_shrinking_children_with_stretch;
 mod align_flex_start_with_stretching_children;
 mod align_items_center;
 mod align_items_center_child_with_margin_bigger_than_parent;
 mod align_items_center_child_without_margin_bigger_than_parent;
+mod align_items_center_justify_content_center;
+mod align_items_center_min_max_with_padding;
 mod align_items_center_with_child_margin;
 mod align_items_center_with_child_top;
 mod align_items_flex_end;
@@ -123,12 +159,15 @@ mod align_items_flex_end_child_without_margin_bigger_than_parent;
 mod align_items_flex_start;
 mod align_items_min_max;
 mod align_items_stretch;
+mod align_items_stretch_min_cross;
 mod align_self_baseline;
 mod align_self_center;
+mod align_self_center_undefined_max_height;
 mod align_self_flex_end;
 mod align_self_flex_end_override_flex_start;
 mod align_self_flex_start;
 mod align_stretch_should_size_based_on_parent;
+mod android_news_feed;
 mod aspect_ratio_flex_column_fill_height;
 mod aspect_ratio_flex_column_fill_max_height;
 mod aspect_ratio_flex_column_fill_max_width;
@@ -152,10 +191,13 @@ mod aspect_ratio_flex_row_stretch_fill_max_height;
 mod aspect_ratio_flex_row_stretch_fill_max_width;
 mod aspect_ratio_flex_row_stretch_fill_width;
 mod border_center_child;
+mod border_container_match_child;
 mod border_flex_child;
 mod border_no_child;
+mod border_no_size;
 mod border_stretch_child;
 mod child_min_max_width_flexing;
+mod child_with_padding_align_end;
 mod container_with_unsized_child;
 mod display_none;
 mod display_none_absolute_child;
@@ -183,9 +225,11 @@ mod flex_basis_smaller_then_content_with_flex_grow_unconstraint_size;
 mod flex_basis_smaller_then_content_with_flex_grow_very_large_size;
 mod flex_basis_unconstraint_column;
 mod flex_basis_unconstraint_row;
+mod flex_basis_zero_undefined_main_size;
 mod flex_direction_column;
 mod flex_direction_column_no_height;
 mod flex_direction_column_reverse;
+mod flex_direction_column_reverse_no_height;
 mod flex_direction_row;
 mod flex_direction_row_no_width;
 mod flex_direction_row_reverse;
@@ -231,6 +275,7 @@ mod gap_column_gap_percentage_cyclic_unshrinkable;
 mod gap_column_gap_percentage_flexible;
 mod gap_column_gap_percentage_flexible_with_padding;
 mod gap_column_gap_percentage_inflexible;
+mod gap_column_gap_row_gap_wrapping;
 mod gap_column_gap_wrap_align_center;
 mod gap_column_gap_wrap_align_flex_end;
 mod gap_column_gap_wrap_align_flex_start;
@@ -578,28 +623,37 @@ mod measure_root;
 mod measure_stretch_overrides_measure;
 mod measure_width_overrides_measure;
 mod min_height;
+mod min_height_larger_than_height;
 mod min_height_overrides_height;
 mod min_height_overrides_height_on_root;
 mod min_height_overrides_max_height;
+mod min_height_with_nested_fixed_height;
+mod min_max_percent_different_width_height;
 mod min_max_percent_no_width_height;
 mod min_width;
+mod min_width_larger_than_width;
 mod min_width_overrides_max_width;
 mod min_width_overrides_width;
 mod min_width_overrides_width_on_root;
 mod nested_overflowing_child;
 mod nested_overflowing_child_in_constraint_parent;
+mod only_shrinkable_item_with_flex_basis_zero;
 mod overflow_cross_axis;
 mod overflow_main_axis;
 mod padding_align_end_child;
 mod padding_center_child;
+mod padding_container_match_child;
 mod padding_flex_child;
 mod padding_no_child;
+mod padding_no_size;
 mod padding_stretch_child;
 mod parent_wrap_child_size_overflowing_parent;
 mod percent_absolute_position;
 mod percent_within_flex_grow;
 mod percentage_absolute_position;
 mod percentage_container_in_wrapping_container;
+mod percentage_different_width_height;
+mod percentage_different_width_height_column;
 mod percentage_flex_basis;
 mod percentage_flex_basis_cross;
 mod percentage_flex_basis_cross_max_height;
@@ -609,6 +663,7 @@ mod percentage_flex_basis_cross_min_width;
 mod percentage_flex_basis_main_max_height;
 mod percentage_flex_basis_main_max_width;
 mod percentage_flex_basis_main_min_width;
+mod percentage_main_max_height;
 mod percentage_margin_should_calculate_based_only_on_width;
 mod percentage_moderate_complexity;
 mod percentage_multiple_nested_with_padding_margin_and_percentage_values;
@@ -628,17 +683,24 @@ mod rounding_fractial_input_1;
 mod rounding_fractial_input_2;
 mod rounding_fractial_input_3;
 mod rounding_fractial_input_4;
+mod rounding_inner_node_controversy_vertical;
 mod rounding_total_fractial;
 mod rounding_total_fractial_nested;
+mod single_flex_child_after_absolute_child;
 mod size_defined_by_child;
 mod size_defined_by_child_with_border;
 mod size_defined_by_child_with_padding;
 mod size_defined_by_grand_child;
+mod undefined_height_with_min_max;
+mod undefined_width_with_min_max;
+mod undefined_width_with_min_max_row;
 mod width_smaller_then_content_with_flex_grow_large_size;
 mod width_smaller_then_content_with_flex_grow_small_size;
 mod width_smaller_then_content_with_flex_grow_unconstraint_size;
 mod width_smaller_then_content_with_flex_grow_very_large_size;
+mod wrap_child;
 mod wrap_column;
+mod wrap_grandchild;
 mod wrap_nodes_with_content_sizing_margin_cross;
 mod wrap_nodes_with_content_sizing_overflowing_margin;
 mod wrap_reverse_column;
@@ -671,6 +733,10 @@ fn benchmark(c: &mut Criterion) {
             absolute_aspect_ratio_fill_width_from_inset::compute();
             absolute_aspect_ratio_height_overrides_inset::compute();
             absolute_aspect_ratio_width_overrides_inset::compute();
+            absolute_child_with_cross_margin::compute();
+            absolute_child_with_main_margin::compute();
+            absolute_child_with_max_height::compute();
+            absolute_child_with_max_height_larger_shrinkable_grandchild::compute();
             absolute_layout_align_items_and_justify_content_center::compute();
             absolute_layout_align_items_and_justify_content_center_and_bottom_position::compute();
             absolute_layout_align_items_and_justify_content_center_and_left_position::compute();
@@ -687,6 +753,8 @@ fn benchmark(c: &mut Criterion) {
             absolute_layout_justify_content_center::compute();
             absolute_layout_no_size::compute();
             absolute_layout_percentage_bottom_based_on_parent_height::compute();
+            absolute_layout_percentage_height::compute();
+            absolute_layout_row_width_height_end_bottom::compute();
             absolute_layout_start_top_end_bottom::compute();
             absolute_layout_width_height_end_bottom::compute();
             absolute_layout_width_height_start_top::compute();
@@ -699,21 +767,51 @@ fn benchmark(c: &mut Criterion) {
             absolute_minmax_top_left_bottom_right_max::compute();
             absolute_minmax_top_left_bottom_right_min_max::compute();
             align_baseline::compute();
+            align_baseline_child::compute();
             align_baseline_child_multiline::compute();
+            align_baseline_child_top::compute();
+            align_baseline_child_top2::compute();
+            align_baseline_column::compute();
+            align_baseline_double_nested_child::compute();
+            align_baseline_multiline_column::compute();
+            align_baseline_multiline_column2::compute();
             align_baseline_nested_child::compute();
+            align_baseline_nested_column::compute();
             align_center_should_size_based_on_content::compute();
+            align_content_flex_end::compute();
+            align_content_flex_start::compute();
+            align_content_flex_start_with_flex::compute();
+            align_content_flex_start_without_height_on_children::compute();
+            align_content_not_stretch_with_align_items_stretch::compute();
             align_content_space_around_single_line::compute();
             align_content_space_around_wrapped::compute();
             align_content_space_between_single_line::compute();
             align_content_space_between_wrapped::compute();
             align_content_space_evenly_single_line::compute();
             align_content_space_evenly_wrapped::compute();
+            align_content_spacearound::compute();
+            align_content_spacebetween::compute();
+            align_content_stretch::compute();
+            align_content_stretch_column::compute();
+            align_content_stretch_is_not_overriding_align_items::compute();
+            align_content_stretch_row::compute();
+            align_content_stretch_row_with_children::compute();
+            align_content_stretch_row_with_fixed_height::compute();
+            align_content_stretch_row_with_flex::compute();
+            align_content_stretch_row_with_flex_no_shrink::compute();
+            align_content_stretch_row_with_margin::compute();
+            align_content_stretch_row_with_max_height::compute();
+            align_content_stretch_row_with_min_height::compute();
+            align_content_stretch_row_with_padding::compute();
+            align_content_stretch_row_with_single_row::compute();
             align_flex_start_with_shrinking_children::compute();
             align_flex_start_with_shrinking_children_with_stretch::compute();
             align_flex_start_with_stretching_children::compute();
             align_items_center::compute();
             align_items_center_child_with_margin_bigger_than_parent::compute();
             align_items_center_child_without_margin_bigger_than_parent::compute();
+            align_items_center_justify_content_center::compute();
+            align_items_center_min_max_with_padding::compute();
             align_items_center_with_child_margin::compute();
             align_items_center_with_child_top::compute();
             align_items_flex_end::compute();
@@ -722,12 +820,15 @@ fn benchmark(c: &mut Criterion) {
             align_items_flex_start::compute();
             align_items_min_max::compute();
             align_items_stretch::compute();
+            align_items_stretch_min_cross::compute();
             align_self_baseline::compute();
             align_self_center::compute();
+            align_self_center_undefined_max_height::compute();
             align_self_flex_end::compute();
             align_self_flex_end_override_flex_start::compute();
             align_self_flex_start::compute();
             align_stretch_should_size_based_on_parent::compute();
+            android_news_feed::compute();
             aspect_ratio_flex_column_fill_height::compute();
             aspect_ratio_flex_column_fill_max_height::compute();
             aspect_ratio_flex_column_fill_max_width::compute();
@@ -751,10 +852,13 @@ fn benchmark(c: &mut Criterion) {
             aspect_ratio_flex_row_stretch_fill_max_width::compute();
             aspect_ratio_flex_row_stretch_fill_width::compute();
             border_center_child::compute();
+            border_container_match_child::compute();
             border_flex_child::compute();
             border_no_child::compute();
+            border_no_size::compute();
             border_stretch_child::compute();
             child_min_max_width_flexing::compute();
+            child_with_padding_align_end::compute();
             container_with_unsized_child::compute();
             display_none::compute();
             display_none_absolute_child::compute();
@@ -782,9 +886,11 @@ fn benchmark(c: &mut Criterion) {
             flex_basis_smaller_then_content_with_flex_grow_very_large_size::compute();
             flex_basis_unconstraint_column::compute();
             flex_basis_unconstraint_row::compute();
+            flex_basis_zero_undefined_main_size::compute();
             flex_direction_column::compute();
             flex_direction_column_no_height::compute();
             flex_direction_column_reverse::compute();
+            flex_direction_column_reverse_no_height::compute();
             flex_direction_row::compute();
             flex_direction_row_no_width::compute();
             flex_direction_row_reverse::compute();
@@ -830,6 +936,7 @@ fn benchmark(c: &mut Criterion) {
             gap_column_gap_percentage_flexible::compute();
             gap_column_gap_percentage_flexible_with_padding::compute();
             gap_column_gap_percentage_inflexible::compute();
+            gap_column_gap_row_gap_wrapping::compute();
             gap_column_gap_wrap_align_center::compute();
             gap_column_gap_wrap_align_flex_end::compute();
             gap_column_gap_wrap_align_flex_start::compute();
@@ -1177,28 +1284,37 @@ fn benchmark(c: &mut Criterion) {
             measure_stretch_overrides_measure::compute();
             measure_width_overrides_measure::compute();
             min_height::compute();
+            min_height_larger_than_height::compute();
             min_height_overrides_height::compute();
             min_height_overrides_height_on_root::compute();
             min_height_overrides_max_height::compute();
+            min_height_with_nested_fixed_height::compute();
+            min_max_percent_different_width_height::compute();
             min_max_percent_no_width_height::compute();
             min_width::compute();
+            min_width_larger_than_width::compute();
             min_width_overrides_max_width::compute();
             min_width_overrides_width::compute();
             min_width_overrides_width_on_root::compute();
             nested_overflowing_child::compute();
             nested_overflowing_child_in_constraint_parent::compute();
+            only_shrinkable_item_with_flex_basis_zero::compute();
             overflow_cross_axis::compute();
             overflow_main_axis::compute();
             padding_align_end_child::compute();
             padding_center_child::compute();
+            padding_container_match_child::compute();
             padding_flex_child::compute();
             padding_no_child::compute();
+            padding_no_size::compute();
             padding_stretch_child::compute();
             parent_wrap_child_size_overflowing_parent::compute();
             percent_absolute_position::compute();
             percent_within_flex_grow::compute();
             percentage_absolute_position::compute();
             percentage_container_in_wrapping_container::compute();
+            percentage_different_width_height::compute();
+            percentage_different_width_height_column::compute();
             percentage_flex_basis::compute();
             percentage_flex_basis_cross::compute();
             percentage_flex_basis_cross_max_height::compute();
@@ -1208,6 +1324,7 @@ fn benchmark(c: &mut Criterion) {
             percentage_flex_basis_main_max_height::compute();
             percentage_flex_basis_main_max_width::compute();
             percentage_flex_basis_main_min_width::compute();
+            percentage_main_max_height::compute();
             percentage_margin_should_calculate_based_only_on_width::compute();
             percentage_moderate_complexity::compute();
             percentage_multiple_nested_with_padding_margin_and_percentage_values::compute();
@@ -1227,17 +1344,24 @@ fn benchmark(c: &mut Criterion) {
             rounding_fractial_input_2::compute();
             rounding_fractial_input_3::compute();
             rounding_fractial_input_4::compute();
+            rounding_inner_node_controversy_vertical::compute();
             rounding_total_fractial::compute();
             rounding_total_fractial_nested::compute();
+            single_flex_child_after_absolute_child::compute();
             size_defined_by_child::compute();
             size_defined_by_child_with_border::compute();
             size_defined_by_child_with_padding::compute();
             size_defined_by_grand_child::compute();
+            undefined_height_with_min_max::compute();
+            undefined_width_with_min_max::compute();
+            undefined_width_with_min_max_row::compute();
             width_smaller_then_content_with_flex_grow_large_size::compute();
             width_smaller_then_content_with_flex_grow_small_size::compute();
             width_smaller_then_content_with_flex_grow_unconstraint_size::compute();
             width_smaller_then_content_with_flex_grow_very_large_size::compute();
+            wrap_child::compute();
             wrap_column::compute();
+            wrap_grandchild::compute();
             wrap_nodes_with_content_sizing_margin_cross::compute();
             wrap_nodes_with_content_sizing_overflowing_margin::compute();
             wrap_reverse_column::compute();
diff --git a/benches/generated/only_shrinkable_item_with_flex_basis_zero.rs b/benches/generated/only_shrinkable_item_with_flex_basis_zero.rs
new file mode 100644
index 000000000..64023180f
--- /dev/null
+++ b/benches/generated/only_shrinkable_item_with_flex_basis_zero.rs
@@ -0,0 +1,44 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Points(0f32),
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_shrink: 0f32,
+            flex_basis: taffy::style::Dimension::Points(93f32),
+            margin: taffy::geometry::Rect {
+                left: zero(),
+                right: zero(),
+                top: zero(),
+                bottom: taffy::style::LengthPercentageAuto::Points(6f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_shrink: 0f32,
+            flex_basis: taffy::style::Dimension::Points(764f32),
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(480f32), height: auto() },
+                max_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(764f32) },
+                ..Default::default()
+            },
+            &[node0, node1, node2],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/padding_container_match_child.rs b/benches/generated/padding_container_match_child.rs
new file mode 100644
index 000000000..d2a9d3da9
--- /dev/null
+++ b/benches/generated/padding_container_match_child.rs
@@ -0,0 +1,30 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(10f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                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()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/padding_no_size.rs b/benches/generated/padding_no_size.rs
new file mode 100644
index 000000000..da5de1074
--- /dev/null
+++ b/benches/generated/padding_no_size.rs
@@ -0,0 +1,17 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node = taffy
+        .new_leaf(taffy::style::Style {
+            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();
+}
diff --git a/benches/generated/percentage_different_width_height.rs b/benches/generated/percentage_different_width_height.rs
new file mode 100644
index 000000000..f72e6a651
--- /dev/null
+++ b/benches/generated/percentage_different_width_height.rs
@@ -0,0 +1,31 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Percent(0.3f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Percent(0.3f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(200f32),
+                    height: taffy::style::Dimension::Points(300f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/percentage_different_width_height_column.rs b/benches/generated/percentage_different_width_height_column.rs
new file mode 100644
index 000000000..1e55f2375
--- /dev/null
+++ b/benches/generated/percentage_different_width_height_column.rs
@@ -0,0 +1,26 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy.new_leaf(taffy::style::Style { flex_grow: 1f32, ..Default::default() }).unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Percent(0.3f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(200f32),
+                    height: taffy::style::Dimension::Points(300f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/percentage_main_max_height.rs b/benches/generated/percentage_main_max_height.rs
new file mode 100644
index 000000000..a9c3f6577
--- /dev/null
+++ b/benches/generated/percentage_main_max_height.rs
@@ -0,0 +1,37 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style { flex_basis: taffy::style::Dimension::Points(15f32), ..Default::default() })
+        .unwrap();
+    let node01 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_basis: taffy::style::Dimension::Points(48f32),
+            max_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Percent(0.33f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_items: Some(taffy::style::AlignItems::Start),
+                size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(151f32) },
+                ..Default::default()
+            },
+            &[node00, node01],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(71f32), height: auto() },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/rounding_inner_node_controversy_vertical.rs b/benches/generated/rounding_inner_node_controversy_vertical.rs
new file mode 100644
index 000000000..e43fa624f
--- /dev/null
+++ b/benches/generated/rounding_inner_node_controversy_vertical.rs
@@ -0,0 +1,48 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(10f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(10f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_grow: 1f32,
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(10f32), height: auto() },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(10f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(320f32) },
+                ..Default::default()
+            },
+            &[node0, node1, node2],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/single_flex_child_after_absolute_child.rs b/benches/generated/single_flex_child_after_absolute_child.rs
new file mode 100644
index 000000000..0d12276fd
--- /dev/null
+++ b/benches/generated/single_flex_child_after_absolute_child.rs
@@ -0,0 +1,38 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::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::Percent(1f32),
+                height: taffy::style::Dimension::Percent(1f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 =
+        taffy.new_leaf(taffy::style::Style { flex_grow: 1f32, flex_shrink: 1f32, ..Default::default() }).unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_shrink: 0f32,
+            flex_basis: taffy::style::Dimension::Points(174f32),
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(428f32),
+                    height: taffy::style::Dimension::Points(845f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/undefined_height_with_min_max.rs b/benches/generated/undefined_height_with_min_max.rs
new file mode 100644
index 000000000..5e9587453
--- /dev/null
+++ b/benches/generated/undefined_height_with_min_max.rs
@@ -0,0 +1,24 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            min_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(0f32) },
+            max_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(100f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(320f32), height: auto() },
+                min_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(0f32) },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/undefined_width_with_min_max.rs b/benches/generated/undefined_width_with_min_max.rs
new file mode 100644
index 000000000..24df79730
--- /dev/null
+++ b/benches/generated/undefined_width_with_min_max.rs
@@ -0,0 +1,23 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::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: auto() },
+            max_size: taffy::geometry::Size { width: taffy::style::Dimension::Points(100f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/undefined_width_with_min_max_row.rs b/benches/generated/undefined_width_with_min_max_row.rs
new file mode 100644
index 000000000..250ac2038
--- /dev/null
+++ b/benches/generated/undefined_width_with_min_max_row.rs
@@ -0,0 +1,34 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(30f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                min_size: taffy::geometry::Size { width: taffy::style::Dimension::Points(60f32), height: auto() },
+                max_size: taffy::geometry::Size { width: taffy::style::Dimension::Points(300f32), height: auto() },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+                ..Default::default()
+            },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/wrap_child.rs b/benches/generated/wrap_child.rs
new file mode 100644
index 000000000..1fe56d68b
--- /dev/null
+++ b/benches/generated/wrap_child.rs
@@ -0,0 +1,21 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node0 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(100f32),
+                height: taffy::style::Dimension::Points(100f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style { flex_direction: taffy::style::FlexDirection::Column, ..Default::default() },
+            &[node0],
+        )
+        .unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/benches/generated/wrap_grandchild.rs b/benches/generated/wrap_grandchild.rs
new file mode 100644
index 000000000..f0717a1e7
--- /dev/null
+++ b/benches/generated/wrap_grandchild.rs
@@ -0,0 +1,17 @@
+pub fn compute() {
+    #[allow(unused_imports)]
+    use taffy::prelude::*;
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(100f32),
+                height: taffy::style::Dimension::Points(100f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node00]).unwrap();
+    let node = taffy.new_with_children(taffy::style::Style { ..Default::default() }, &[node0]).unwrap();
+    taffy.compute_layout(node, taffy::geometry::Size::MAX_CONTENT).unwrap();
+}
diff --git a/scripts/diff-test-fixtures-with-yoga.sh b/scripts/diff-test-fixtures-with-yoga.sh
new file mode 100755
index 000000000..e0aa1675b
--- /dev/null
+++ b/scripts/diff-test-fixtures-with-yoga.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+if [[ ${YOGA_FIXTURE_DIR+dummy} == "" ]]; then
+  echo "Error: YOGA_FIXTURE_DIR not set";
+  echo "Please set the YOGA_FIXTURE_DIR environment variable to the absolute path of the gentest/fixtures dir in a local copy of the yoga repo";
+  exit 1;
+fi
+
+if [ ! -d "$YOGA_FIXTURE_DIR" ]; then
+  echo "YOGA_FIXTURE_DIR directory $YOGA_FIXTURE_DIR does not exist."
+  exit 1;
+fi
+
+YOGA_TEST_LIST=$(rg '<div id="([a-z_]*)".*' --replace '$1' -o --no-line-number --no-filename $YOGA_FIXTURE_DIR | grep -v '^$' | sed -E 's/^(column_row|row|column)_gap/gap_\1_gap/' | sort)
+
+TAFFY_FIXTURE_DIR=$(SELF=$(dirname "$0") && bash -c "cd \"$SELF\" && cd ../test_fixtures && pwd")
+TAFFY_TEST_LIST=$(cd $TAFFY_FIXTURE_DIR && fd -x echo {.} | grep -v '^grid' | sed -E 's/^x(.*)/\1--disabled/' | sort)
+
+diff -U 1000000 --color <(echo "$YOGA_TEST_LIST") <(echo "$TAFFY_TEST_LIST")
\ No newline at end of file
diff --git a/scripts/import-yoga-tests/Cargo.toml b/scripts/import-yoga-tests/Cargo.toml
new file mode 100644
index 000000000..eb0a19dd1
--- /dev/null
+++ b/scripts/import-yoga-tests/Cargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "import-yoga-test"
+version = "0.1.0"
+authors = ["Nico Burns"]
+edition = "2021"
diff --git a/scripts/import-yoga-tests/FIXTURE_TEMPLATE.html b/scripts/import-yoga-tests/FIXTURE_TEMPLATE.html
new file mode 100644
index 000000000..3a3d1b7b5
--- /dev/null
+++ b/scripts/import-yoga-tests/FIXTURE_TEMPLATE.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+__HTML_GOES_HERE__
+
+</body>
+</html>
\ No newline at end of file
diff --git a/scripts/import-yoga-tests/README.md b/scripts/import-yoga-tests/README.md
new file mode 100644
index 000000000..1c7ac7846
--- /dev/null
+++ b/scripts/import-yoga-tests/README.md
@@ -0,0 +1,13 @@
+# Import Yoga Tests script
+
+This is a rough and ready script for the purpose of syncing test fixtures from the [Yoga](https://github.com/facebook/yoga/) which Taffy's predecessor Stretch was originally descended from, and whose tests are compatible with Taffy's generated test infrastructure.
+
+## Usage
+
+- Clone the [yoga](https://github.com/facebook/yoga/) repo locally
+- Set the `YOGA_FIXTURE_DIR` environment variable to the absolute path of `gentest/fixtures` directory within your local copy of the repo
+- Run `cargo run` in this directory (or `cargo import-yoga-tests` in the root directory of the Taffy repo)
+- Manually inspect the imported tests (if any - there may not be any new tests since the last sync) to check that they make sense for Taffy (and that they're not for example testing features we don't implement)
+- Run `cargo gentest` in the root directory of the Taffy repo to generate actual tests from the fixtures
+- Run `cargo test` to ensure that the new tests pass
+- If any tests do not pass, either fix them or prefix the fixture file with an `x` to disable it (e.g. `align_content_stretch.html` would become `xalign_content_stretch.html`) and rerun `cargo gentest` to automatically remove the generated tests for that fixture.
diff --git a/scripts/import-yoga-tests/src/main.rs b/scripts/import-yoga-tests/src/main.rs
new file mode 100644
index 000000000..be481a840
--- /dev/null
+++ b/scripts/import-yoga-tests/src/main.rs
@@ -0,0 +1,78 @@
+use std::collections::HashSet;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+struct YogaFixture {
+    #[allow(dead_code)]
+    file_name: PathBuf,
+    name: String,
+    content: String,
+}
+
+fn main() {
+    // Get Taffy fixtures dir
+    let script_root_dir = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
+    let taffy_repo_root = script_root_dir.parent().and_then(Path::parent).unwrap();
+    let taffy_fixtures_dir = taffy_repo_root.join("test_fixtures");
+
+    // Get Taffy fixture names
+    let taffy_fixture_names = fs::read_dir(&taffy_fixtures_dir)
+        .unwrap()
+        .filter_map(|a| a.ok())
+        .map(|f| {
+            let file_name = f.file_name();
+            let file_name = if file_name.to_string_lossy().starts_with('x') {
+                file_name.to_string_lossy()[1..].replace(".html", "")
+            } else {
+                file_name.to_string_lossy().replace(".html", "")
+            };
+            file_name
+        })
+        .collect::<HashSet<String>>();
+
+    // Get Taffy fixture template
+    let fixture_template_path = script_root_dir.join("FIXTURE_TEMPLATE.html");
+    let fixture_template = fs::read_to_string(fixture_template_path).unwrap();
+
+    // Get Yoga fixtures dir
+    let yoga_fixtures_dir =
+        PathBuf::from(std::env::var("YOGA_FIXTURE_DIR").expect("YOGA_FIXTURE_DIR env var must be set"));
+    let fixtures_file_list = fs::read_dir(yoga_fixtures_dir).unwrap();
+
+    let yoga_fixtures: Vec<YogaFixture> = fixtures_file_list
+        .filter_map(|a| a.ok())
+        .filter(|f| f.path().is_file() && f.path().extension().map(|p| p == "html").unwrap_or(false))
+        .flat_map(|f| {
+            let file_name: PathBuf = f.file_name().into();
+
+            let file_content = fs::read_to_string(f.path()).unwrap();
+
+            file_content
+                .split("\n\n")
+                .map(|snippet| {
+                    let snippet = snippet.trim();
+                    let first_quote_idx = snippet.chars().position(|c| c == '"').unwrap();
+                    let name: String = snippet.chars().skip(first_quote_idx + 1).take_while(|c| *c != '"').collect();
+                    let name_replace_snippet = snippet.replace(&name, "test-root");
+
+                    let taffy_name = {
+                        let name = name.replace("row_gap", "gap_row_gap");
+                        name.replace("column_gap", "gap_column_gap")
+                    };
+                    YogaFixture { file_name: file_name.clone(), name: taffy_name, content: name_replace_snippet }
+                })
+                .collect::<Vec<_>>()
+        })
+        .collect();
+
+    for fixture in yoga_fixtures {
+        if !taffy_fixture_names.contains(&fixture.name) {
+            let mut new_fixture_path = taffy_fixtures_dir.join(&fixture.name);
+            new_fixture_path.set_extension("html");
+            let new_fixture_content = fixture_template.replace("__HTML_GOES_HERE__", &fixture.content);
+
+            println!("Writing new fixture {}", &fixture.name);
+            fs::write(new_fixture_path, new_fixture_content).unwrap();
+        }
+    }
+}
diff --git a/src/compute/flexbox.rs b/src/compute/flexbox.rs
index da92c3b31..a77d25037 100644
--- a/src/compute/flexbox.rs
+++ b/src/compute/flexbox.rs
@@ -117,6 +117,8 @@ struct AlgoConstants {
     gap: Size<f32>,
     /// The align_items property of this node
     align_items: AlignItems,
+    /// The align_content property of this node
+    align_content: AlignContent,
 
     /// The content-box size of the node being laid out (if known)
     node_inner_size: Size<Option<f32>>,
@@ -293,7 +295,7 @@ fn compute_preliminary(
     // 9. Handle 'align-content: stretch'.
     #[cfg(feature = "debug")]
     NODE_LOGGER.log("handle_align_content_stretch");
-    handle_align_content_stretch(tree, &mut flex_lines, node, known_dimensions, &constants);
+    handle_align_content_stretch(&mut flex_lines, known_dimensions, &constants);
 
     // 10. Collapse visibility:collapse items. If any flex items have visibility: collapse,
     //     note the cross size of the line they’re in as the item’s strut size, and restart
@@ -399,6 +401,7 @@ fn compute_constants(
     let padding = style.padding.resolve_or_zero(parent_size.width);
     let border = style.border.resolve_or_zero(parent_size.width);
     let align_items = style.align_items.unwrap_or(crate::style::AlignItems::Stretch);
+    let align_content = style.align_content.unwrap_or(crate::style::AlignContent::Stretch);
 
     let padding_border = padding + border;
 
@@ -430,6 +433,7 @@ fn compute_constants(
         gap,
         padding_border,
         align_items,
+        align_content,
         node_inner_size,
         container_size,
         inner_container_size,
@@ -1092,7 +1096,15 @@ fn calculate_cross_size(
     node_size: Size<Option<f32>>,
     constants: &AlgoConstants,
 ) {
-    if flex_lines.len() == 1 && node_size.cross(constants.dir).is_some() {
+    // Note: AlignContent::SpaceEvenly and AlignContent::SpaceAround behave like AlignContent::Stretch when there is only
+    // a single flex line in the container. See: https://www.w3.org/TR/css-flexbox-1/#align-content-property
+    if flex_lines.len() == 1
+        && node_size.cross(constants.dir).is_some()
+        && matches!(
+            constants.align_content,
+            AlignContent::Stretch | AlignContent::SpaceEvenly | AlignContent::SpaceAround
+        )
+    {
         flex_lines[0].cross_size =
             (node_size.cross(constants.dir).maybe_sub(constants.padding_border.cross_axis_sum(constants.dir)))
                 .unwrap_or(0.0);
@@ -1139,15 +1151,8 @@ fn calculate_cross_size(
 ///     and the sum of the flex lines' cross sizes is less than the flex container’s inner cross size,
 ///     increase the cross size of each flex line by equal amounts such that the sum of their cross sizes exactly equals the flex container’s inner cross size.
 #[inline]
-fn handle_align_content_stretch(
-    tree: &mut impl LayoutTree,
-    flex_lines: &mut [FlexLine],
-    node: Node,
-    node_size: Size<Option<f32>>,
-    constants: &AlgoConstants,
-) {
-    let align_content = tree.style(node).align_content.unwrap_or(AlignContent::Stretch);
-    if align_content == AlignContent::Stretch && node_size.cross(constants.dir).is_some() {
+fn handle_align_content_stretch(flex_lines: &mut [FlexLine], node_size: Size<Option<f32>>, constants: &AlgoConstants) {
+    if constants.align_content == AlignContent::Stretch && node_size.cross(constants.dir).is_some() {
         let total_cross_axis_gap = sum_axis_gaps(constants.gap.cross(constants.dir), flex_lines.len());
         let total_cross: f32 = flex_lines.iter().map(|line| line.cross_size).sum::<f32>() + total_cross_axis_gap;
         let inner_cross =
diff --git a/test_fixtures/absolute_child_with_cross_margin.html b/test_fixtures/absolute_child_with_cross_margin.html
new file mode 100644
index 000000000..3cde0c751
--- /dev/null
+++ b/test_fixtures/absolute_child_with_cross_margin.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root"
+  style="flex-direction: row; justify-content: space-between; max-width: 311px; max-height: 3.68935e+19px; min-width: 311px; min-height: 0px; ">
+  <div style="flex-direction: row; align-content: stretch; width:28px; height:27px"></div>
+  <div
+    style="flex-direction: row; align-content: stretch; flex-grow: 0; flex-shrink: 1; margin-top: 4px; width: 100%; height: 15px; position: absolute;">
+  </div>
+  <div style="flex-direction: row; align-content: stretch; width:25px; height:27px"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/absolute_child_with_main_margin.html b/test_fixtures/absolute_child_with_main_margin.html
new file mode 100644
index 000000000..53e78980e
--- /dev/null
+++ b/test_fixtures/absolute_child_with_main_margin.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: row; width: 20px; height: 37px">
+  <div style="width: 9px; height: 9px; position: absolute; margin-left: 7px"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/absolute_child_with_max_height.html b/test_fixtures/absolute_child_with_max_height.html
new file mode 100644
index 000000000..4f6048c89
--- /dev/null
+++ b/test_fixtures/absolute_child_with_max_height.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 100px; height: 200px">
+  <div style="flex-direction: column;position: absolute; bottom: 20px; max-height: 100px;">
+    <div style="width: 100px; height: 30px"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/absolute_child_with_max_height_larger_shrinkable_grandchild.html b/test_fixtures/absolute_child_with_max_height_larger_shrinkable_grandchild.html
new file mode 100644
index 000000000..1219d5286
--- /dev/null
+++ b/test_fixtures/absolute_child_with_max_height_larger_shrinkable_grandchild.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 100px; height: 200px">
+  <div style="flex-direction: column;position: absolute; bottom: 20px; max-height: 100px;">
+    <div style="width: 100px; flex-basis: 150px; flex-shrink: 1;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/absolute_layout_percentage_height.html b/test_fixtures/absolute_layout_percentage_height.html
new file mode 100644
index 000000000..22d97bfaf
--- /dev/null
+++ b/test_fixtures/absolute_layout_percentage_height.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 200px; height: 100px;">
+  <div style="width:10px; height: 50%; position: absolute; left: 10px; top: 10px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/absolute_layout_row_width_height_end_bottom.html b/test_fixtures/absolute_layout_row_width_height_end_bottom.html
new file mode 100644
index 000000000..5d9552144
--- /dev/null
+++ b/test_fixtures/absolute_layout_row_width_height_end_bottom.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="width:10px; height: 10px; position: absolute; right: 10px; bottom: 10px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_baseline_child.html b/test_fixtures/align_baseline_child.html
new file mode 100644
index 000000000..d409dc2be
--- /dev/null
+++ b/test_fixtures/align_baseline_child.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 100px; height: 100px; flex-direction:row; align-items: baseline;">
+  <div style="width: 50px; height: 50px;"></div>
+  <div style="flex-direction: column;width: 50px; height: 20px;">
+    <div style="width: 50px; height: 10px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_baseline_child_top.html b/test_fixtures/align_baseline_child_top.html
new file mode 100644
index 000000000..a6d67bfbc
--- /dev/null
+++ b/test_fixtures/align_baseline_child_top.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:row; align-items: baseline;">
+  <div style="width: 50px; height: 50px;top:10px;"></div>
+  <div style="flex-direction: column;width: 50px; height: 20px;">
+    <div style="width: 50px; height: 10px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_baseline_child_top2.html b/test_fixtures/align_baseline_child_top2.html
new file mode 100644
index 000000000..469c56ddd
--- /dev/null
+++ b/test_fixtures/align_baseline_child_top2.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:row; align-items: baseline;">
+  <div style="width: 50px; height: 50px;"></div>
+  <div style="width: 50px; height: 20px;top:5px">
+    <div style="width: 50px; height: 10px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_baseline_column.html b/test_fixtures/align_baseline_column.html
new file mode 100644
index 000000000..1c1f1ca43
--- /dev/null
+++ b/test_fixtures/align_baseline_column.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:column; align-items: baseline;">
+  <div style="width: 50px; height: 50px;"></div>
+  <div style="width: 50px; height: 20px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_baseline_double_nested_child.html b/test_fixtures/align_baseline_double_nested_child.html
new file mode 100644
index 000000000..9b1433d39
--- /dev/null
+++ b/test_fixtures/align_baseline_double_nested_child.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:row; align-items: baseline;">
+  <div style="width: 50px; height: 50px;">
+    <div style="width: 50px; height: 20px;"></div>
+  </div>
+  <div style="width: 50px; height: 20px;">
+    <div style="width: 50px; height: 15px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_baseline_multiline_column.html b/test_fixtures/align_baseline_multiline_column.html
new file mode 100644
index 000000000..e71b5da87
--- /dev/null
+++ b/test_fixtures/align_baseline_multiline_column.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:column; align-items: baseline;flex-wrap:wrap;">
+  <div style="width: 50px; height: 50px;"></div>
+  <div style="flex-direction: column;width: 30px; height: 50px;">
+    <div style="width: 20px; height: 20px;"></div>
+  </div>
+  <div style="flex-direction: column;width: 40px; height: 70px;">
+    <div style="width: 10px; height: 10px;"></div>
+  </div>
+  <div style="width: 50px; height: 20px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_baseline_multiline_column2.html b/test_fixtures/align_baseline_multiline_column2.html
new file mode 100644
index 000000000..9ee12b420
--- /dev/null
+++ b/test_fixtures/align_baseline_multiline_column2.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:column; align-items: baseline;flex-wrap:wrap;">
+  <div style="width: 50px; height: 50px;flex-direction:column;"></div>
+  <div style="width: 30px; height: 50px;flex-direction:column;">
+    <div style="width: 20px; height: 20px;flex-direction:column;"></div>
+  </div>
+  <div style="width: 40px; height: 70px;flex-direction:column;">
+    <div style="width: 10px; height: 10px;flex-direction:column;"></div>
+  </div>
+  <div style="width: 50px; height: 20px;flex-direction:column;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_baseline_nested_column.html b/test_fixtures/align_baseline_nested_column.html
new file mode 100644
index 000000000..34737e3f2
--- /dev/null
+++ b/test_fixtures/align_baseline_nested_column.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction: row; align-items: baseline;">
+  <div style="width: 50px; height: 60px;"></div>
+  <div style="flex-direction: column;">
+    <div style="width: 50px; height: 80px; flex-direction: column;">
+      <div style="flex-direction: column;width: 50px; height: 30px;"></div>
+      <div style="flex-direction: column;width: 50px; height: 40px;"></div>
+    </div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_flex_end.html b/test_fixtures/align_content_flex_end.html
new file mode 100644
index 000000000..eca04ca39
--- /dev/null
+++ b/test_fixtures/align_content_flex_end.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-wrap: wrap; flex-direction: column; align-content: flex-end;">
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_flex_start.html b/test_fixtures/align_content_flex_start.html
new file mode 100644
index 000000000..900ce8b9b
--- /dev/null
+++ b/test_fixtures/align_content_flex_start.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 130px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: flex-start;">
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_flex_start_with_flex.html b/test_fixtures/align_content_flex_start_with_flex.html
new file mode 100644
index 000000000..21ca6ed20
--- /dev/null
+++ b/test_fixtures/align_content_flex_start_with_flex.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 120px; flex-wrap: wrap; flex-direction: column; align-content: flex-start;">
+  <div style="width: 50px; flex: 1; flex-shrink: 0;"></div>
+  <div style="width: 50px; flex: 1; height: 10px; flex-shrink: 0;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; flex: 1;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_flex_start_without_height_on_children.html b/test_fixtures/align_content_flex_start_without_height_on_children.html
new file mode 100644
index 000000000..c892859ed
--- /dev/null
+++ b/test_fixtures/align_content_flex_start_without_height_on_children.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-wrap: wrap; flex-direction: column; align-content: flex-start;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_not_stretch_with_align_items_stretch.html b/test_fixtures/align_content_not_stretch_with_align_items_stretch.html
new file mode 100644
index 000000000..fa11e197b
--- /dev/null
+++ b/test_fixtures/align_content_not_stretch_with_align_items_stretch.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root"
+  style="width: 328px; height: 52px; flex-direction: row; align-content: flex-start; flex-wrap: wrap;">
+  <div style="flex-direction: column;">
+    <div style="width: 272px; height: 44px;"></div>
+  </div>
+  <div style="flex-direction: column;">
+    <div style="width: 56px; height: 44px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_spacearound.html b/test_fixtures/align_content_spacearound.html
new file mode 100644
index 000000000..65dadeb85
--- /dev/null
+++ b/test_fixtures/align_content_spacearound.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 140px; height: 120px; flex-wrap: wrap; flex-direction: row; align-content: space-around;">
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+</div>
+
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_spacebetween.html b/test_fixtures/align_content_spacebetween.html
new file mode 100644
index 000000000..07ea78a6a
--- /dev/null
+++ b/test_fixtures/align_content_spacebetween.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 130px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: space-between;">
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch.html b/test_fixtures/align_content_stretch.html
new file mode 100644
index 000000000..fdef0f239
--- /dev/null
+++ b/test_fixtures/align_content_stretch.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: column; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_column.html b/test_fixtures/align_content_stretch_column.html
new file mode 100644
index 000000000..2417a372f
--- /dev/null
+++ b/test_fixtures/align_content_stretch_column.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 150px; flex-wrap: wrap; flex-direction: column; align-content: stretch;">
+  <div style="flex-direction: column;height: 50px;">
+    <div style="flex: 1;"></div>
+  </div>
+  <div style="height: 50px; flex: 1;"></div>
+  <div style="height: 50px;"></div>
+  <div style="height: 50px;"></div>
+  <div style="height: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_is_not_overriding_align_items.html b/test_fixtures/align_content_stretch_is_not_overriding_align_items.html
new file mode 100644
index 000000000..47b825c7e
--- /dev/null
+++ b/test_fixtures/align_content_stretch_is_not_overriding_align_items.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="align-content:stretch;">
+  <div style="width:100px; height: 100px; align-items: center; flex-direction: row; align-content:stretch;">
+    <div style="height: 10px; width: 10px; align-content:stretch;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_row.html b/test_fixtures/align_content_stretch_row.html
new file mode 100644
index 000000000..0018d042b
--- /dev/null
+++ b/test_fixtures/align_content_stretch_row.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_row_with_children.html b/test_fixtures/align_content_stretch_row_with_children.html
new file mode 100644
index 000000000..ef2bc0d2a
--- /dev/null
+++ b/test_fixtures/align_content_stretch_row_with_children.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: stretch;">
+  <div style="flex-direction: column;width: 50px;">
+    <div style="flex: 1;"></div>
+  </div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_row_with_fixed_height.html b/test_fixtures/align_content_stretch_row_with_fixed_height.html
new file mode 100644
index 000000000..c62d01a6d
--- /dev/null
+++ b/test_fixtures/align_content_stretch_row_with_fixed_height.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; height: 60px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_row_with_flex.html b/test_fixtures/align_content_stretch_row_with_flex.html
new file mode 100644
index 000000000..154e86c71
--- /dev/null
+++ b/test_fixtures/align_content_stretch_row_with_flex.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; flex: 1;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; flex: 1;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_row_with_flex_no_shrink.html b/test_fixtures/align_content_stretch_row_with_flex_no_shrink.html
new file mode 100644
index 000000000..0af576405
--- /dev/null
+++ b/test_fixtures/align_content_stretch_row_with_flex_no_shrink.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; flex: 1;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; flex: 1; flex-shrink: 0;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_row_with_margin.html b/test_fixtures/align_content_stretch_row_with_margin.html
new file mode 100644
index 000000000..6850153a9
--- /dev/null
+++ b/test_fixtures/align_content_stretch_row_with_margin.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; margin: 10px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; margin: 10px;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_row_with_max_height.html b/test_fixtures/align_content_stretch_row_with_max_height.html
new file mode 100644
index 000000000..c04d88bd2
--- /dev/null
+++ b/test_fixtures/align_content_stretch_row_with_max_height.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; max-height: 20px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_row_with_min_height.html b/test_fixtures/align_content_stretch_row_with_min_height.html
new file mode 100644
index 000000000..5fc3d5794
--- /dev/null
+++ b/test_fixtures/align_content_stretch_row_with_min_height.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; min-height: 80px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_row_with_padding.html b/test_fixtures/align_content_stretch_row_with_padding.html
new file mode 100644
index 000000000..a51a89a5a
--- /dev/null
+++ b/test_fixtures/align_content_stretch_row_with_padding.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; padding: 10px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px; padding: 10px;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_content_stretch_row_with_single_row.html b/test_fixtures/align_content_stretch_row_with_single_row.html
new file mode 100644
index 000000000..bdebfab23
--- /dev/null
+++ b/test_fixtures/align_content_stretch_row_with_single_row.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 150px; height: 100px; flex-wrap: wrap; flex-direction: row; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_items_center_justify_content_center.html b/test_fixtures/align_items_center_justify_content_center.html
new file mode 100644
index 000000000..c8b5831fc
--- /dev/null
+++ b/test_fixtures/align_items_center_justify_content_center.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;height: 500px; width: 500px">
+  <div style="flex-direction: column;align-items: center; justify-content: center; height: 50px">
+    <div style="flex-direction: column;align-items: center; justify-content: center; height: 100%; margin-left: 10px; margin-right: 10px;">
+      <div style="width: 10px; height: 10px;">
+      </div>
+    </div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_items_center_min_max_with_padding.html b/test_fixtures/align_items_center_min_max_with_padding.html
new file mode 100644
index 000000000..795dd318f
--- /dev/null
+++ b/test_fixtures/align_items_center_min_max_with_padding.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: row; max-width: 320px; min-width: 320px; min-height: 72px; max-height: 504px; align-items: center; padding-top: 8px; padding-bottom: 8px;">
+  <div style="width: 62px; height: 62px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_items_stretch_min_cross.html b/test_fixtures/align_items_stretch_min_cross.html
new file mode 100644
index 000000000..d38f2b6a6
--- /dev/null
+++ b/test_fixtures/align_items_stretch_min_cross.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column; min-width: 400px; min-height: 50px;">
+  <div style="flex-shrink: 0; height: 36px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/align_self_center_undefined_max_height.html b/test_fixtures/align_self_center_undefined_max_height.html
new file mode 100644
index 000000000..79b1f5d9a
--- /dev/null
+++ b/test_fixtures/align_self_center_undefined_max_height.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 280px; min-height: 52px; flex-direction: row;">
+  <div style="height: 44px; width: 240px;"></div>
+  <div style="height: 56px; width: 40px; align-self: center;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/android_news_feed.html b/test_fixtures/android_news_feed.html
new file mode 100644
index 000000000..78b28184a
--- /dev/null
+++ b/test_fixtures/android_news_feed.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+  <div id="test-root" layout="width: 1080; height: 444; top: 0; left: 0;" style="flex-direction: column;align-content: stretch; flex-shrink: 0; width: 1080px; " >
+    <div layout="width: 1080; height: 444; top: 0; left: 0;" style="flex-direction: column;flex-shrink: 0; " >
+      <div layout="width: 1080; height: 444; top: 0; left: 0;" style="flex-direction: column;align-content: stretch; " >
+        <div layout="width: 1080; height: 226; top: 0; left: 0;" style="flex-direction: column;align-content: stretch; " >
+          <div layout="width: 1044; height: 202; top: 24; left: 36;" style="flex-direction: row; align-items: flex-start; align-content: stretch; margin-top: 24px; margin-left: 36px; " >
+            <div layout="width: 120; height: 120; top: 0; left: 0;" style="flex-direction: row; align-content: stretch; flex-shrink: 0; " >
+              <div layout="width: 120; height: 120; top: 0; left: 0;" style="align-content: stretch; flex-shrink: 0; width: 120px; height: 120px; " has-custom-measure="true"></div>
+            </div>
+            <div layout="width: 870; height: 202; top: 0; left: 138;" style="flex-direction: column;align-content: stretch; flex-shrink: 1; margin-right: 36px; padding-left: 36px; padding-top: 21px; padding-right: 36px; padding-bottom: 18px; " >
+              <div layout="width: 798; height: 49; top: 21; left: 36;" style="flex-direction: row; align-content: stretch; flex-shrink: 1; " has-custom-measure="true"></div>
+              <div layout="width: 798; height: 114; top: 70; left: 36;" style="align-content: stretch; flex-shrink: 1; " has-custom-measure="true"></div>
+            </div>
+          </div>
+        </div>
+        <div layout="width: 1080; height: 218; top: 226; left: 0;" style="flex-direction: column;align-content: stretch; " >
+          <div layout="width: 906; height: 194; top: 24; left: 174;" style="flex-direction: row; align-items: flex-start; align-content: stretch; margin-top: 24px; margin-left: 174px; " >
+            <div layout="width: 72; height: 72; top: 12; left: 0;" style="flex-direction: row; align-content: stretch; flex-shrink: 0; " >
+              <div layout="width: 72; height: 72; top: 0; left: 0;" style="align-content: stretch; flex-shrink: 0; width: 72px; height: 72px; " has-custom-measure="true"></div>
+            </div>
+            <div layout="width: 780; height: 194; top: 0; left: 90;" style="flex-direction: column;align-content: stretch; flex-shrink: 1; margin-right: 36px; padding-left: 36px; padding-top: 21px; padding-right: 36px; padding-bottom: 18px; " >
+              <div layout="width: 708; height: 49; top: 21; left: 36;" style="flex-direction: row; align-content: stretch; flex-shrink: 1; " has-custom-measure="true"></div>
+              <div layout="width: 708; height: 106; top: 70; left: 36;" style="align-content: stretch; flex-shrink: 1; " has-custom-measure="true"></div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/border_container_match_child.html b/test_fixtures/border_container_match_child.html
new file mode 100644
index 000000000..3077defd7
--- /dev/null
+++ b/test_fixtures/border_container_match_child.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;border-width: 10px;">
+  <div style="width: 10px; height: 10px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/border_no_size.html b/test_fixtures/border_no_size.html
new file mode 100644
index 000000000..98a75d7cd
--- /dev/null
+++ b/test_fixtures/border_no_size.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;border-width: 10px;"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/child_with_padding_align_end.html b/test_fixtures/child_with_padding_align_end.html
new file mode 100644
index 000000000..3a6362bdf
--- /dev/null
+++ b/test_fixtures/child_with_padding_align_end.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 200px; height: 200px; justify-content: flex-end; align-items: flex-end;">
+  <div style="width: 100px; height: 100px; padding: 20px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/flex_basis_zero_undefined_main_size.html b/test_fixtures/flex_basis_zero_undefined_main_size.html
new file mode 100644
index 000000000..e8717812d
--- /dev/null
+++ b/test_fixtures/flex_basis_zero_undefined_main_size.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: row;">
+  <div style="flex-direction: column;flex-basis: 0px;">
+    <div style="width: 100px; height: 50px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/flex_direction_column_reverse_no_height.html b/test_fixtures/flex_direction_column_reverse_no_height.html
new file mode 100644
index 000000000..37f7f521b
--- /dev/null
+++ b/test_fixtures/flex_direction_column_reverse_no_height.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; flex-direction: column-reverse;">
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/gap_column_gap_row_gap_wrapping.html b/test_fixtures/gap_column_gap_row_gap_wrapping.html
new file mode 100644
index 000000000..db64565d3
--- /dev/null
+++ b/test_fixtures/gap_column_gap_row_gap_wrapping.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: row; flex-wrap: wrap; width: 80px; column-gap: 10px; row-gap: 20px;">
+  <div style="width: 20px; height: 20px"></div>
+  <div style="width: 20px; height: 20px"></div>
+  <div style="width: 20px; height: 20px"></div>
+  <div style="width: 20px; height: 20px"></div>
+  <div style="width: 20px; height: 20px"></div>
+  <div style="width: 20px; height: 20px"></div>
+  <div style="width: 20px; height: 20px"></div>
+  <div style="width: 20px; height: 20px"></div>
+  <div style="width: 20px; height: 20px"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/min_height_larger_than_height.html b/test_fixtures/min_height_larger_than_height.html
new file mode 100644
index 000000000..29698c456
--- /dev/null
+++ b/test_fixtures/min_height_larger_than_height.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="height: 25px; min-height: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/min_height_with_nested_fixed_height.html b/test_fixtures/min_height_with_nested_fixed_height.html
new file mode 100644
index 000000000..596ac9528
--- /dev/null
+++ b/test_fixtures/min_height_with_nested_fixed_height.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 320px; min-height: 44px; flex-direction: row; padding-left: 16px; padding-right: 16px;">
+  <div style="flex-direction: column;min-height: 28px; align-self: flex-start; flex-shrink: 0; margin-bottom: 9px; margin-top: 8px;">
+    <div style="width: 40px; height: 40px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/min_max_percent_different_width_height.html b/test_fixtures/min_max_percent_different_width_height.html
new file mode 100644
index 000000000..a95c9a829
--- /dev/null
+++ b/test_fixtures/min_max_percent_different_width_height.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 100px; height: 200px; align-items: flex-start;">
+  <div style="min-width: 10%; max-width: 10%; min-height: 10%; max-height: 10%;">
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/min_width_larger_than_width.html b/test_fixtures/min_width_larger_than_width.html
new file mode 100644
index 000000000..f74bc3d4f
--- /dev/null
+++ b/test_fixtures/min_width_larger_than_width.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 100px; height: 100px;">
+  <div style="width: 25px; min-width: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/only_shrinkable_item_with_flex_basis_zero.html b/test_fixtures/only_shrinkable_item_with_flex_basis_zero.html
new file mode 100644
index 000000000..2f80d6808
--- /dev/null
+++ b/test_fixtures/only_shrinkable_item_with_flex_basis_zero.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column; width: 480px; max-height: 764px;">
+  <div style="flex-basis: 0px; flex-shrink: 1;"></div>
+  <div style="margin-bottom: 6px; flex-shrink: 0; flex-basis: 93px;"></div>
+  <div style="flex-shrink: 0; flex-basis: 764px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/padding_container_match_child.html b/test_fixtures/padding_container_match_child.html
new file mode 100644
index 000000000..2f99d908c
--- /dev/null
+++ b/test_fixtures/padding_container_match_child.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;padding: 10px;">
+  <div style="width: 10px; height: 10px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/padding_no_size.html b/test_fixtures/padding_no_size.html
new file mode 100644
index 000000000..22562edd9
--- /dev/null
+++ b/test_fixtures/padding_no_size.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="padding: 10px;"></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/percentage_different_width_height.html b/test_fixtures/percentage_different_width_height.html
new file mode 100644
index 000000000..2fe1e20d8
--- /dev/null
+++ b/test_fixtures/percentage_different_width_height.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 200px; height: 300px; flex-direction: row;">
+  <div style="height: 30%; flex-grow: 1"></div>
+  <div style="height: 30%;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/percentage_different_width_height_column.html b/test_fixtures/percentage_different_width_height_column.html
new file mode 100644
index 000000000..b1e1c3528
--- /dev/null
+++ b/test_fixtures/percentage_different_width_height_column.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 200px; height: 300px; flex-direction: column;">
+  <div style="flex-grow: 1"></div>
+  <div style="height: 30%;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/percentage_main_max_height.html b/test_fixtures/percentage_main_max_height.html
new file mode 100644
index 000000000..529fd5d7d
--- /dev/null
+++ b/test_fixtures/percentage_main_max_height.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 71px;">
+  <div style="flex-direction: column;align-items: flex-start; height: 151px;">
+    <div style="flex-basis: 15px;"></div>
+    <div style="flex-basis: 48px; max-height: 33%;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/rounding_inner_node_controversy_vertical.html b/test_fixtures/rounding_inner_node_controversy_vertical.html
new file mode 100644
index 000000000..ded8d8a19
--- /dev/null
+++ b/test_fixtures/rounding_inner_node_controversy_vertical.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;height: 320px;">
+  <div style="width: 10px; flex-grow:1;"></div>
+  <div style="flex-direction: column;width: 10px; flex-grow:1;">
+    <div style="width: 10px; flex-grow:1;"></div>
+  </div>
+  <div style="width: 10px; flex-grow:1;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/single_flex_child_after_absolute_child.html b/test_fixtures/single_flex_child_after_absolute_child.html
new file mode 100644
index 000000000..6b5016143
--- /dev/null
+++ b/test_fixtures/single_flex_child_after_absolute_child.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 428px; height: 845px">
+  <div style="width: 100%; height: 100%; position: absolute;"></div>
+  <div style="flex-grow: 1; flex-shrink: 1;"></div>
+  <div style="flex-shrink: 0; flex-basis: 174px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/undefined_height_with_min_max.html b/test_fixtures/undefined_height_with_min_max.html
new file mode 100644
index 000000000..e14583af6
--- /dev/null
+++ b/test_fixtures/undefined_height_with_min_max.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 320px; min-height: 0px;">
+  <div style="min-height: 0px; max-height: 100px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/undefined_width_with_min_max.html b/test_fixtures/undefined_width_with_min_max.html
new file mode 100644
index 000000000..7455d290b
--- /dev/null
+++ b/test_fixtures/undefined_width_with_min_max.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;height: 50px;">
+  <div style="min-width: 0px; max-width: 100px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/undefined_width_with_min_max_row.html b/test_fixtures/undefined_width_with_min_max_row.html
new file mode 100644
index 000000000..098507858
--- /dev/null
+++ b/test_fixtures/undefined_width_with_min_max_row.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="height: 50px; flex-direction: row;">
+  <div style="min-width: 60px; max-width: 300px;">
+    <div style="width: 30px; height: 20px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/wrap_child.html b/test_fixtures/wrap_child.html
new file mode 100644
index 000000000..def27ed35
--- /dev/null
+++ b/test_fixtures/wrap_child.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;">
+  <div style="width: 100px; height: 100px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/wrap_grandchild.html b/test_fixtures/wrap_grandchild.html
new file mode 100644
index 000000000..1030077bf
--- /dev/null
+++ b/test_fixtures/wrap_grandchild.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root">
+  <div>
+    <div style="width: 100px; height: 100px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xalign_baseline_child_margin.html b/test_fixtures/xalign_baseline_child_margin.html
new file mode 100644
index 000000000..79e7e4422
--- /dev/null
+++ b/test_fixtures/xalign_baseline_child_margin.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:row; align-items: baseline;">
+  <div style="width: 50px; height: 50px;margin: 5px;"></div>
+  <div style="flex-direction: column;width: 50px; height: 20px;">
+    <div style="width: 50px; height: 10px;margin: 1px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xalign_baseline_child_margin_percent.html b/test_fixtures/xalign_baseline_child_margin_percent.html
new file mode 100644
index 000000000..f09750188
--- /dev/null
+++ b/test_fixtures/xalign_baseline_child_margin_percent.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:row; align-items: baseline;">
+  <div style="width: 50px; height: 50px;margin: 5%;"></div>
+  <div style="flex-direction: column;width: 50px; height: 20px;">
+    <div style="width: 50px; height: 10px;margin: 1%;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xalign_baseline_child_multiline_no_override_on_secondline.html b/test_fixtures/xalign_baseline_child_multiline_no_override_on_secondline.html
new file mode 100644
index 000000000..2108330db
--- /dev/null
+++ b/test_fixtures/xalign_baseline_child_multiline_no_override_on_secondline.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:row; align-items: baseline;">
+  <div style="width: 50px; height: 60px;"></div>
+  <div style="width: 50px; height: 25px;flex-wrap:wrap;flex-direction:row;">
+    <div style="width: 25px; height: 20px;"></div>
+    <div style="width: 25px; height: 10px;"></div>
+    <div style="width: 25px; height: 20px;"></div>
+    <div style="width: 25px; height: 10px;align-self:baseline;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xalign_baseline_child_multiline_override.html b/test_fixtures/xalign_baseline_child_multiline_override.html
new file mode 100644
index 000000000..c4f2b6c6f
--- /dev/null
+++ b/test_fixtures/xalign_baseline_child_multiline_override.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:row; align-items: baseline;">
+  <div style="width: 50px; height: 60px;"></div>
+  <div style="width: 50px; height: 25px;flex-wrap:wrap;flex-direction:row;">
+    <div style="width: 25px; height: 20px;"></div>
+    <div style="width: 25px; height: 10px;align-self:baseline;"></div>
+    <div style="width: 25px; height: 20px;"></div>
+    <div style="width: 25px; height: 10px;align-self:baseline;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xalign_baseline_child_padding.html b/test_fixtures/xalign_baseline_child_padding.html
new file mode 100644
index 000000000..51c015b9a
--- /dev/null
+++ b/test_fixtures/xalign_baseline_child_padding.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; padding:5px; flex-direction:row; align-items: baseline;">
+  <div style="width: 50px; height: 50px;"></div>
+  <div style="flex-direction: column;width: 50px; height: 20px;padding:5px;">
+    <div style="width: 50px; height: 10px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xalign_baseline_multiline.html b/test_fixtures/xalign_baseline_multiline.html
new file mode 100644
index 000000000..9a5647980
--- /dev/null
+++ b/test_fixtures/xalign_baseline_multiline.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:row; align-items: baseline;flex-wrap:wrap;">
+  <div style="width: 50px; height: 50px;"></div>
+  <div style="flex-direction: column;width: 50px; height: 20px;">
+    <div style="width: 50px; height: 10px;"></div>
+  </div>
+  <div style="flex-direction: column;width: 50px; height: 20px;">
+    <div style="width: 50px; height: 10px;"></div>
+  </div>
+  <div style="width: 50px; height: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xalign_baseline_multiline_row_and_column.html b/test_fixtures/xalign_baseline_multiline_row_and_column.html
new file mode 100644
index 000000000..2dc5290aa
--- /dev/null
+++ b/test_fixtures/xalign_baseline_multiline_row_and_column.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction:row; align-items: baseline;flex-wrap:wrap;">
+  <div style="width: 50px; height: 50px;"></div>
+  <div style="width: 50px; height: 50px;flex-direction:column;">
+    <div style="width: 50px; height: 10px;"></div>
+  </div>
+  <div style="width: 50px; height: 20px;flex-direction:column;">
+    <div style="width: 50px; height: 10px;"></div>
+  </div>
+  <div style="width: 50px; height: 20px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xdo_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hidden_parent.html b/test_fixtures/xdo_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hidden_parent.html
new file mode 100644
index 000000000..a118d7b42
--- /dev/null
+++ b/test_fixtures/xdo_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hidden_parent.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="height: 50px; width: 50px; overflow: hidden; flex-direction: row;">
+  <div style="flex-direction: column;position: absolute; left: 0px; top: 0px;">
+    <div style="width: 100px; height: 100px;"></div>
+  </div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xjustify_content_column_min_height_and_margin.html b/test_fixtures/xjustify_content_column_min_height_and_margin.html
new file mode 100644
index 000000000..d1716ad1b
--- /dev/null
+++ b/test_fixtures/xjustify_content_column_min_height_and_margin.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="min-height: 50px; margin-top: 100px; justify-content: center; flex-direction: column;">
+  <div style="height: 20px; width: 20px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xjustify_content_colunn_max_height_and_margin.html b/test_fixtures/xjustify_content_colunn_max_height_and_margin.html
new file mode 100644
index 000000000..8d1a2d4ea
--- /dev/null
+++ b/test_fixtures/xjustify_content_colunn_max_height_and_margin.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="height: 100px; max-height: 80px; margin-top: 100px; justify-content: center; flex-direction: column;">
+  <div style="height: 20px; width: 20px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xmargin_auto_start_and_end.html b/test_fixtures/xmargin_auto_start_and_end.html
new file mode 100644
index 000000000..da8f9d978
--- /dev/null
+++ b/test_fixtures/xmargin_auto_start_and_end.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="flex-direction: column;width: 200px; height: 200px; ">
+  <div style="width: 50px; height: 50px; margin-inline-start: auto; margin-inline-end: auto;"></div>
+  <div style="width: 50px; height: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xmargin_auto_start_and_end_column.html b/test_fixtures/xmargin_auto_start_and_end_column.html
new file mode 100644
index 000000000..43daa3bdd
--- /dev/null
+++ b/test_fixtures/xmargin_auto_start_and_end_column.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 200px; height: 200px; align-items: center; flex-direction: row;">
+  <div style="width: 50px; height: 50px; margin-inline-start: auto; margin-inline-end: auto;"></div>
+  <div style="width: 50px; height: 50px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xmargin_end.html b/test_fixtures/xmargin_end.html
new file mode 100644
index 000000000..cbc392ce0
--- /dev/null
+++ b/test_fixtures/xmargin_end.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction: row; justify-content: flex-end;">
+  <div style="width: 10px; margin-inline-end: 10px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xmargin_start.html b/test_fixtures/xmargin_start.html
new file mode 100644
index 000000000..6a2613f28
--- /dev/null
+++ b/test_fixtures/xmargin_start.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="width: 10px; margin-inline-start: 10px;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xposition_root_with_rtl_should_position_withoutdirection.html b/test_fixtures/xposition_root_with_rtl_should_position_withoutdirection.html
new file mode 100644
index 000000000..bedbd0b21
--- /dev/null
+++ b/test_fixtures/xposition_root_with_rtl_should_position_withoutdirection.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="height: 52px; width: 52px; left: 72px; "></div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xrounding_inner_node_controversy_combined.html b/test_fixtures/xrounding_inner_node_controversy_combined.html
new file mode 100644
index 000000000..3e30fd484
--- /dev/null
+++ b/test_fixtures/xrounding_inner_node_controversy_combined.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 640px; height: 320px; flex-direction: row;">
+  <div style="height: 100%; flex-grow:1;"></div>
+  <div style="height: 100%; flex-grow:1; flex-direction: column;">
+    <div style="width: 100%; flex-grow:1;"></div>
+    <div style="flex-direction: column;width: 100%; flex-grow:1;">
+      <div style="flex-grow:1; width: 100%;">
+      </div>
+    </div>
+    <div style="width: 100%; flex-grow:1;"></div>
+  </div>
+  <div style="height: 100%; flex-grow:1;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test_fixtures/xrounding_inner_node_controversy_horizontal.html b/test_fixtures/xrounding_inner_node_controversy_horizontal.html
new file mode 100644
index 000000000..0d9049cff
--- /dev/null
+++ b/test_fixtures/xrounding_inner_node_controversy_horizontal.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script src="../scripts/gentest/test_helper.js"></script>
+  <link rel="stylesheet" type="text/css" href="../scripts/gentest/test_base_style.css">
+  <title>
+    Test description
+  </title>
+<head/>
+<body>
+
+<div id="test-root" style="width: 320px; flex-direction: row;">
+  <div style="height: 10px; flex-grow:1;"></div>
+  <div style="flex-direction: column;height: 10px; flex-grow:1;">
+    <div style="height: 10px; flex-grow:1;"></div>
+  </div>
+  <div style="height: 10px; flex-grow:1;"></div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/tests/generated/absolute_child_with_cross_margin.rs b/tests/generated/absolute_child_with_cross_margin.rs
new file mode 100644
index 000000000..16a000901
--- /dev/null
+++ b/tests/generated/absolute_child_with_cross_margin.rs
@@ -0,0 +1,99 @@
+#[test]
+fn absolute_child_with_cross_margin() {
+    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 {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(28f32),
+                height: taffy::style::Dimension::Points(27f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf_with_measure(
+            taffy::style::Style {
+                position: taffy::style::Position::Absolute,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                flex_grow: 0f32,
+                flex_shrink: 1f32,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Percent(1f32),
+                    height: taffy::style::Dimension::Points(15f32),
+                },
+                margin: taffy::geometry::Rect {
+                    left: zero(),
+                    right: zero(),
+                    top: taffy::style::LengthPercentageAuto::Points(4f32),
+                    bottom: zero(),
+                },
+                ..Default::default()
+            },
+            taffy::node::MeasureFunc::Raw(|known_dimensions, available_space| {
+                const TEXT: &str = "\n  ";
+                super::measure_standard_text(
+                    known_dimensions,
+                    available_space,
+                    TEXT,
+                    super::WritingMode::Horizontal,
+                    None,
+                )
+            }),
+        )
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(25f32),
+                height: taffy::style::Dimension::Points(27f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                justify_content: Some(taffy::style::JustifyContent::SpaceBetween),
+                min_size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(311f32),
+                    height: taffy::style::Dimension::Points(0f32),
+                },
+                max_size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(311f32),
+                    height: taffy::style::Dimension::Points(36893500000000000000f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2],
+        )
+        .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, 311f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 311f32, size.width);
+    assert_eq!(size.height, 27f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 27f32, 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, 27f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 27f32, 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, 311f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 311f32, size.width);
+    assert_eq!(size.height, 15f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 15f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.x);
+    assert_eq!(location.y, 4f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 4f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 25f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 25f32, size.width);
+    assert_eq!(size.height, 27f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 27f32, size.height);
+    assert_eq!(location.x, 286f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 286f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+}
diff --git a/tests/generated/absolute_child_with_main_margin.rs b/tests/generated/absolute_child_with_main_margin.rs
new file mode 100644
index 000000000..a2a94166c
--- /dev/null
+++ b/tests/generated/absolute_child_with_main_margin.rs
@@ -0,0 +1,49 @@
+#[test]
+fn absolute_child_with_main_margin() {
+    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(9f32),
+                height: taffy::style::Dimension::Points(9f32),
+            },
+            margin: taffy::geometry::Rect {
+                left: taffy::style::LengthPercentageAuto::Points(7f32),
+                right: zero(),
+                top: zero(),
+                bottom: zero(),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(20f32),
+                    height: taffy::style::Dimension::Points(37f32),
+                },
+                ..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, 37f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 37f32, 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, 9f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 9f32, size.width);
+    assert_eq!(size.height, 9f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 9f32, size.height);
+    assert_eq!(location.x, 7f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 7f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.y);
+}
diff --git a/tests/generated/absolute_child_with_max_height.rs b/tests/generated/absolute_child_with_max_height.rs
new file mode 100644
index 000000000..2eb2ae443
--- /dev/null
+++ b/tests/generated/absolute_child_with_max_height.rs
@@ -0,0 +1,65 @@
+#[test]
+fn absolute_child_with_max_height() {
+    use slotmap::Key;
+    #[allow(unused_imports)]
+    use taffy::{layout::Layout, prelude::*};
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(100f32),
+                height: taffy::style::Dimension::Points(30f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                position: taffy::style::Position::Absolute,
+                flex_direction: taffy::style::FlexDirection::Column,
+                max_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(100f32) },
+                inset: taffy::geometry::Rect {
+                    left: auto(),
+                    right: auto(),
+                    top: auto(),
+                    bottom: taffy::style::LengthPercentageAuto::Points(20f32),
+                },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(200f32),
+                },
+                ..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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 200f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 200f32, 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, 100f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 100f32, size.width);
+    assert_eq!(size.height, 30f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 30f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+    assert_eq!(location.y, 150f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 150f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node00).unwrap();
+    assert_eq!(size.width, 100f32, "width of node {:?}. Expected {}. Actual {}", node00.data(), 100f32, size.width);
+    assert_eq!(size.height, 30f32, "height of node {:?}. Expected {}. Actual {}", node00.data(), 30f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.y);
+}
diff --git a/tests/generated/absolute_child_with_max_height_larger_shrinkable_grandchild.rs b/tests/generated/absolute_child_with_max_height_larger_shrinkable_grandchild.rs
new file mode 100644
index 000000000..7ebfd8c7c
--- /dev/null
+++ b/tests/generated/absolute_child_with_max_height_larger_shrinkable_grandchild.rs
@@ -0,0 +1,64 @@
+#[test]
+fn absolute_child_with_max_height_larger_shrinkable_grandchild() {
+    use slotmap::Key;
+    #[allow(unused_imports)]
+    use taffy::{layout::Layout, prelude::*};
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Points(150f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(100f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                position: taffy::style::Position::Absolute,
+                flex_direction: taffy::style::FlexDirection::Column,
+                max_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(100f32) },
+                inset: taffy::geometry::Rect {
+                    left: auto(),
+                    right: auto(),
+                    top: auto(),
+                    bottom: taffy::style::LengthPercentageAuto::Points(20f32),
+                },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(200f32),
+                },
+                ..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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 200f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 200f32, 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, 100f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 100f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+    assert_eq!(location.y, 80f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 80f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node00).unwrap();
+    assert_eq!(size.width, 100f32, "width of node {:?}. Expected {}. Actual {}", node00.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node00.data(), 100f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.y);
+}
diff --git a/tests/generated/absolute_layout_percentage_height.rs b/tests/generated/absolute_layout_percentage_height.rs
new file mode 100644
index 000000000..94de4d50f
--- /dev/null
+++ b/tests/generated/absolute_layout_percentage_height.rs
@@ -0,0 +1,49 @@
+#[test]
+fn absolute_layout_percentage_height() {
+    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(10f32),
+                height: taffy::style::Dimension::Percent(0.5f32),
+            },
+            inset: taffy::geometry::Rect {
+                left: taffy::style::LengthPercentageAuto::Points(10f32),
+                right: auto(),
+                top: taffy::style::LengthPercentageAuto::Points(10f32),
+                bottom: auto(),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(200f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..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, 200f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 200f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 10f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 10f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.height);
+    assert_eq!(location.x, 10f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 10f32, location.x);
+    assert_eq!(location.y, 10f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 10f32, location.y);
+}
diff --git a/tests/generated/absolute_layout_row_width_height_end_bottom.rs b/tests/generated/absolute_layout_row_width_height_end_bottom.rs
new file mode 100644
index 000000000..32eed63f9
--- /dev/null
+++ b/tests/generated/absolute_layout_row_width_height_end_bottom.rs
@@ -0,0 +1,49 @@
+#[test]
+fn absolute_layout_row_width_height_end_bottom() {
+    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(10f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            inset: taffy::geometry::Rect {
+                left: auto(),
+                right: taffy::style::LengthPercentageAuto::Points(10f32),
+                top: auto(),
+                bottom: taffy::style::LengthPercentageAuto::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 10f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 10f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 10f32, size.height);
+    assert_eq!(location.x, 80f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 80f32, location.x);
+    assert_eq!(location.y, 80f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 80f32, location.y);
+}
diff --git a/tests/generated/align_baseline_child.rs b/tests/generated/align_baseline_child.rs
new file mode 100644
index 000000000..f84c79cf9
--- /dev/null
+++ b/tests/generated/align_baseline_child.rs
@@ -0,0 +1,75 @@
+#[test]
+fn align_baseline_child() {
+    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(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(20f32),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 20f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 40f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 40f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node10).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node10.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node10.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.y);
+}
diff --git a/tests/generated/align_baseline_child_top.rs b/tests/generated/align_baseline_child_top.rs
new file mode 100644
index 000000000..26f147947
--- /dev/null
+++ b/tests/generated/align_baseline_child_top.rs
@@ -0,0 +1,81 @@
+#[test]
+fn align_baseline_child_top() {
+    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(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            inset: taffy::geometry::Rect {
+                left: auto(),
+                right: auto(),
+                top: taffy::style::LengthPercentageAuto::Points(10f32),
+                bottom: auto(),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(20f32),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+    assert_eq!(location.y, 10f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 10f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node1).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 20f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 40f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 40f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node10).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node10.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node10.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.y);
+}
diff --git a/tests/generated/align_baseline_child_top2.rs b/tests/generated/align_baseline_child_top2.rs
new file mode 100644
index 000000000..d60dd7078
--- /dev/null
+++ b/tests/generated/align_baseline_child_top2.rs
@@ -0,0 +1,80 @@
+#[test]
+fn align_baseline_child_top2() {
+    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(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(20f32),
+                },
+                inset: taffy::geometry::Rect {
+                    left: auto(),
+                    right: auto(),
+                    top: taffy::style::LengthPercentageAuto::Points(5f32),
+                    bottom: auto(),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 20f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 45f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 45f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node10).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node10.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node10.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.y);
+}
diff --git a/tests/generated/align_baseline_column.rs b/tests/generated/align_baseline_column.rs
new file mode 100644
index 000000000..ffd486a47
--- /dev/null
+++ b/tests/generated/align_baseline_column.rs
@@ -0,0 +1,58 @@
+#[test]
+fn align_baseline_column() {
+    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(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 20f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.y);
+}
diff --git a/tests/generated/align_baseline_double_nested_child.rs b/tests/generated/align_baseline_double_nested_child.rs
new file mode 100644
index 000000000..1d18ae2f4
--- /dev/null
+++ b/tests/generated/align_baseline_double_nested_child.rs
@@ -0,0 +1,91 @@
+#[test]
+fn align_baseline_double_nested_child() {
+    use slotmap::Key;
+    #[allow(unused_imports)]
+    use taffy::{layout::Layout, prelude::*};
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(50f32),
+                },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(15f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(20f32),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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(node00).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node00.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node00.data(), 20f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node1).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 20f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 5f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 5f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node10).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node10.data(), 50f32, size.width);
+    assert_eq!(size.height, 15f32, "height of node {:?}. Expected {}. Actual {}", node10.data(), 15f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.y);
+}
diff --git a/tests/generated/align_baseline_multiline_column.rs b/tests/generated/align_baseline_multiline_column.rs
new file mode 100644
index 000000000..e2665a809
--- /dev/null
+++ b/tests/generated/align_baseline_multiline_column.rs
@@ -0,0 +1,123 @@
+#[test]
+fn align_baseline_multiline_column() {
+    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(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(30f32),
+                    height: taffy::style::Dimension::Points(50f32),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node20 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(10f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(40f32),
+                    height: taffy::style::Dimension::Points(70f32),
+                },
+                ..Default::default()
+            },
+            &[node20],
+        )
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3],
+        )
+        .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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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, 30f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 30f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node10).unwrap();
+    assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node10.data(), 20f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node10.data(), 20f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 40f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 40f32, size.width);
+    assert_eq!(size.height, 70f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 70f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node20).unwrap();
+    assert_eq!(size.width, 10f32, "width of node {:?}. Expected {}. Actual {}", node20.data(), 10f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node20.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node20.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node20.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 20f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.x);
+    assert_eq!(location.y, 70f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 70f32, location.y);
+}
diff --git a/tests/generated/align_baseline_multiline_column2.rs b/tests/generated/align_baseline_multiline_column2.rs
new file mode 100644
index 000000000..d9373c8ef
--- /dev/null
+++ b/tests/generated/align_baseline_multiline_column2.rs
@@ -0,0 +1,127 @@
+#[test]
+fn align_baseline_multiline_column2() {
+    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_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(50f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(20f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(30f32),
+                    height: taffy::style::Dimension::Points(50f32),
+                },
+                ..Default::default()
+            },
+            &[node10],
+        )
+        .unwrap();
+    let node20 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(10f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(40f32),
+                    height: taffy::style::Dimension::Points(70f32),
+                },
+                ..Default::default()
+            },
+            &[node20],
+        )
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(20f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3],
+        )
+        .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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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, 30f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 30f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node10).unwrap();
+    assert_eq!(size.width, 20f32, "width of node {:?}. Expected {}. Actual {}", node10.data(), 20f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node10.data(), 20f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 40f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 40f32, size.width);
+    assert_eq!(size.height, 70f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 70f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node20).unwrap();
+    assert_eq!(size.width, 10f32, "width of node {:?}. Expected {}. Actual {}", node20.data(), 10f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node20.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node20.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node20.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 20f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.x);
+    assert_eq!(location.y, 70f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 70f32, location.y);
+}
diff --git a/tests/generated/align_baseline_nested_column.rs b/tests/generated/align_baseline_nested_column.rs
new file mode 100644
index 000000000..1916bdd50
--- /dev/null
+++ b/tests/generated/align_baseline_nested_column.rs
@@ -0,0 +1,102 @@
+#[test]
+fn align_baseline_nested_column() {
+    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(50f32),
+                height: taffy::style::Dimension::Points(60f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node100 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(30f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node101 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_direction: taffy::style::FlexDirection::Column,
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(40f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node10 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(50f32),
+                    height: taffy::style::Dimension::Points(80f32),
+                },
+                ..Default::default()
+            },
+            &[node100, node101],
+        )
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style { flex_direction: taffy::style::FlexDirection::Column, ..Default::default() },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Baseline),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 60f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 60f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 80f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 80f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 30f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 30f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node10).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node10.data(), 50f32, size.width);
+    assert_eq!(size.height, 80f32, "height of node {:?}. Expected {}. Actual {}", node10.data(), 80f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node100).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node100.data(), 50f32, size.width);
+    assert_eq!(size.height, 30f32, "height of node {:?}. Expected {}. Actual {}", node100.data(), 30f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node100.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node100.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node101).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node101.data(), 50f32, size.width);
+    assert_eq!(size.height, 40f32, "height of node {:?}. Expected {}. Actual {}", node101.data(), 40f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node101.data(), 0f32, location.x);
+    assert_eq!(location.y, 30f32, "y of node {:?}. Expected {}. Actual {}", node101.data(), 30f32, location.y);
+}
diff --git a/tests/generated/align_content_flex_end.rs b/tests/generated/align_content_flex_end.rs
new file mode 100644
index 000000000..bb0f6c6cb
--- /dev/null
+++ b/tests/generated/align_content_flex_end.rs
@@ -0,0 +1,101 @@
+#[test]
+fn align_content_flex_end() {
+    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(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::End),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 10f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 10f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, location.x);
+    assert_eq!(location.y, 20f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 20f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.x);
+    assert_eq!(location.y, 30f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 30f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.x);
+    assert_eq!(location.y, 40f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 40f32, location.y);
+}
diff --git a/tests/generated/align_content_flex_start.rs b/tests/generated/align_content_flex_start.rs
new file mode 100644
index 000000000..7e377dd7e
--- /dev/null
+++ b/tests/generated/align_content_flex_start.rs
@@ -0,0 +1,100 @@
+#[test]
+fn align_content_flex_start() {
+    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(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Start),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(130f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 130f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 130f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 10f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.x);
+    assert_eq!(location.y, 10f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 10f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.x);
+    assert_eq!(location.y, 10f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 10f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.x);
+    assert_eq!(location.y, 20f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 20f32, location.y);
+}
diff --git a/tests/generated/align_content_flex_start_with_flex.rs b/tests/generated/align_content_flex_start_with_flex.rs
new file mode 100644
index 000000000..b8cc1e237
--- /dev/null
+++ b/tests/generated/align_content_flex_start_with_flex.rs
@@ -0,0 +1,98 @@
+#[test]
+fn align_content_flex_start_with_flex() {
+    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_shrink: 0f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 0f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Start),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(120f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 120f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 120f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 40f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 40f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 40f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 40f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.x);
+    assert_eq!(location.y, 40f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 40f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.x);
+    assert_eq!(location.y, 80f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 80f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 40f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 40f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.x);
+    assert_eq!(location.y, 80f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 80f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.x);
+    assert_eq!(location.y, 120f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 120f32, location.y);
+}
diff --git a/tests/generated/align_content_flex_start_without_height_on_children.rs b/tests/generated/align_content_flex_start_without_height_on_children.rs
new file mode 100644
index 000000000..d27e72a23
--- /dev/null
+++ b/tests/generated/align_content_flex_start_without_height_on_children.rs
@@ -0,0 +1,92 @@
+#[test]
+fn align_content_flex_start_without_height_on_children() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Start),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.x);
+    assert_eq!(location.y, 10f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 10f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.x);
+    assert_eq!(location.y, 10f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 10f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.x);
+    assert_eq!(location.y, 20f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 20f32, location.y);
+}
diff --git a/tests/generated/align_content_not_stretch_with_align_items_stretch.rs b/tests/generated/align_content_not_stretch_with_align_items_stretch.rs
new file mode 100644
index 000000000..923a9b87b
--- /dev/null
+++ b/tests/generated/align_content_not_stretch_with_align_items_stretch.rs
@@ -0,0 +1,80 @@
+#[test]
+fn align_content_not_stretch_with_align_items_stretch() {
+    use slotmap::Key;
+    #[allow(unused_imports)]
+    use taffy::{layout::Layout, prelude::*};
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(272f32),
+                height: taffy::style::Dimension::Points(44f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style { flex_direction: taffy::style::FlexDirection::Column, ..Default::default() },
+            &[node00],
+        )
+        .unwrap();
+    let node10 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(56f32),
+                height: taffy::style::Dimension::Points(44f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_with_children(
+            taffy::style::Style { flex_direction: taffy::style::FlexDirection::Column, ..Default::default() },
+            &[node10],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Start),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(328f32),
+                    height: taffy::style::Dimension::Points(52f32),
+                },
+                ..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, 328f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 328f32, size.width);
+    assert_eq!(size.height, 52f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 52f32, 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, 272f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 272f32, size.width);
+    assert_eq!(size.height, 44f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 44f32, 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(node00).unwrap();
+    assert_eq!(size.width, 272f32, "width of node {:?}. Expected {}. Actual {}", node00.data(), 272f32, size.width);
+    assert_eq!(size.height, 44f32, "height of node {:?}. Expected {}. Actual {}", node00.data(), 44f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node1).unwrap();
+    assert_eq!(size.width, 56f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 56f32, size.width);
+    assert_eq!(size.height, 44f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 44f32, size.height);
+    assert_eq!(location.x, 272f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 272f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node10).unwrap();
+    assert_eq!(size.width, 56f32, "width of node {:?}. Expected {}. Actual {}", node10.data(), 56f32, size.width);
+    assert_eq!(size.height, 44f32, "height of node {:?}. Expected {}. Actual {}", node10.data(), 44f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node10.data(), 0f32, location.y);
+}
diff --git a/tests/generated/align_content_spacearound.rs b/tests/generated/align_content_spacearound.rs
new file mode 100644
index 000000000..c5e224916
--- /dev/null
+++ b/tests/generated/align_content_spacearound.rs
@@ -0,0 +1,100 @@
+#[test]
+fn align_content_spacearound() {
+    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(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::SpaceAround),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(140f32),
+                    height: taffy::style::Dimension::Points(120f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 140f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 140f32, size.width);
+    assert_eq!(size.height, 120f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 120f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, location.x);
+    assert_eq!(location.y, 15f32, "y of node {:?}. Expected {}. Actual {}", node0.data(), 15f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node1).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 15f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 15f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.x);
+    assert_eq!(location.y, 55f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 55f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.x);
+    assert_eq!(location.y, 55f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 55f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.x);
+    assert_eq!(location.y, 95f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 95f32, location.y);
+}
diff --git a/tests/generated/align_content_spacebetween.rs b/tests/generated/align_content_spacebetween.rs
new file mode 100644
index 000000000..2b008d827
--- /dev/null
+++ b/tests/generated/align_content_spacebetween.rs
@@ -0,0 +1,100 @@
+#[test]
+fn align_content_spacebetween() {
+    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(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::SpaceBetween),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(130f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 130f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 130f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 10f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.x);
+    assert_eq!(location.y, 45f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 45f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.x);
+    assert_eq!(location.y, 45f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 45f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.x);
+    assert_eq!(location.y, 90f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 90f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch.rs b/tests/generated/align_content_stretch.rs
new file mode 100644
index 000000000..8fcb25ece
--- /dev/null
+++ b/tests/generated/align_content_stretch.rs
@@ -0,0 +1,86 @@
+#[test]
+fn align_content_stretch() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 0f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_column.rs b/tests/generated/align_content_stretch_column.rs
new file mode 100644
index 000000000..a45c46c04
--- /dev/null
+++ b/tests/generated/align_content_stretch_column.rs
@@ -0,0 +1,106 @@
+#[test]
+fn align_content_stretch_column() {
+    use slotmap::Key;
+    #[allow(unused_imports)]
+    use taffy::{layout::Layout, prelude::*};
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(50f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(150f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 150f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 150f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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(node00).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node00.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node00.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node1).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 0f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.x);
+    assert_eq!(location.y, 100f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 100f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_is_not_overriding_align_items.rs b/tests/generated/align_content_stretch_is_not_overriding_align_items.rs
new file mode 100644
index 000000000..47898fd2a
--- /dev/null
+++ b/tests/generated/align_content_stretch_is_not_overriding_align_items.rs
@@ -0,0 +1,56 @@
+#[test]
+fn align_content_stretch_is_not_overriding_align_items() {
+    use slotmap::Key;
+    #[allow(unused_imports)]
+    use taffy::{layout::Layout, prelude::*};
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            align_content: Some(taffy::style::AlignContent::Stretch),
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(10f32),
+                height: taffy::style::Dimension::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                align_items: Some(taffy::style::AlignItems::Center),
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(100f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style { align_content: Some(taffy::style::AlignContent::Stretch), ..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, 100f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 100f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 100f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 100f32, 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(node00).unwrap();
+    assert_eq!(size.width, 10f32, "width of node {:?}. Expected {}. Actual {}", node00.data(), 10f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node00.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.x);
+    assert_eq!(location.y, 45f32, "y of node {:?}. Expected {}. Actual {}", node00.data(), 45f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_row.rs b/tests/generated/align_content_stretch_row.rs
new file mode 100644
index 000000000..510e1c7d0
--- /dev/null
+++ b/tests/generated/align_content_stretch_row.rs
@@ -0,0 +1,85 @@
+#[test]
+fn align_content_stretch_row() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.height);
+    assert_eq!(location.x, 100f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 100f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_row_with_children.rs b/tests/generated/align_content_stretch_row_with_children.rs
new file mode 100644
index 000000000..7dcb1cca1
--- /dev/null
+++ b/tests/generated/align_content_stretch_row_with_children.rs
@@ -0,0 +1,102 @@
+#[test]
+fn align_content_stretch_row_with_children() {
+    use slotmap::Key;
+    #[allow(unused_imports)]
+    use taffy::{layout::Layout, prelude::*};
+    let mut taffy = taffy::Taffy::new();
+    let node00 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            ..Default::default()
+        })
+        .unwrap();
+    let node0 = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_direction: taffy::style::FlexDirection::Column,
+                size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+                ..Default::default()
+            },
+            &[node00],
+        )
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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(node00).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node00.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node00.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node00.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node1).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.height);
+    assert_eq!(location.x, 100f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 100f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_row_with_fixed_height.rs b/tests/generated/align_content_stretch_row_with_fixed_height.rs
new file mode 100644
index 000000000..612b8a7a9
--- /dev/null
+++ b/tests/generated/align_content_stretch_row_with_fixed_height.rs
@@ -0,0 +1,88 @@
+#[test]
+fn align_content_stretch_row_with_fixed_height() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size {
+                width: taffy::style::Dimension::Points(50f32),
+                height: taffy::style::Dimension::Points(60f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 80f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 80f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 60f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 60f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 80f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 80f32, size.height);
+    assert_eq!(location.x, 100f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 100f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 20f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.x);
+    assert_eq!(location.y, 80f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 80f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 20f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.x);
+    assert_eq!(location.y, 80f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 80f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_row_with_flex.rs b/tests/generated/align_content_stretch_row_with_flex.rs
new file mode 100644
index 000000000..f183ef3a0
--- /dev/null
+++ b/tests/generated/align_content_stretch_row_with_flex.rs
@@ -0,0 +1,91 @@
+#[test]
+fn align_content_stretch_row_with_flex() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 100f32, 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, 0f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 100f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 100f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 0f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 100f32, size.height);
+    assert_eq!(location.x, 100f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 100f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 100f32, size.height);
+    assert_eq!(location.x, 100f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 100f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_row_with_flex_no_shrink.rs b/tests/generated/align_content_stretch_row_with_flex_no_shrink.rs
new file mode 100644
index 000000000..d6eb91bc5
--- /dev/null
+++ b/tests/generated/align_content_stretch_row_with_flex_no_shrink.rs
@@ -0,0 +1,91 @@
+#[test]
+fn align_content_stretch_row_with_flex_no_shrink() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 1f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            flex_grow: 1f32,
+            flex_shrink: 0f32,
+            flex_basis: taffy::style::Dimension::Percent(0f32),
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 100f32, 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, 0f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 100f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 100f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 0f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 100f32, size.height);
+    assert_eq!(location.x, 100f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 100f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 100f32, size.height);
+    assert_eq!(location.x, 100f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 100f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_row_with_margin.rs b/tests/generated/align_content_stretch_row_with_margin.rs
new file mode 100644
index 000000000..9a9c08b6b
--- /dev/null
+++ b/tests/generated/align_content_stretch_row_with_margin.rs
@@ -0,0 +1,97 @@
+#[test]
+fn align_content_stretch_row_with_margin() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            margin: taffy::geometry::Rect {
+                left: taffy::style::LengthPercentageAuto::Points(10f32),
+                right: taffy::style::LengthPercentageAuto::Points(10f32),
+                top: taffy::style::LengthPercentageAuto::Points(10f32),
+                bottom: taffy::style::LengthPercentageAuto::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            margin: taffy::geometry::Rect {
+                left: taffy::style::LengthPercentageAuto::Points(10f32),
+                right: taffy::style::LengthPercentageAuto::Points(10f32),
+                top: taffy::style::LengthPercentageAuto::Points(10f32),
+                bottom: taffy::style::LengthPercentageAuto::Points(10f32),
+            },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 40f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 40f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 20f32, size.height);
+    assert_eq!(location.x, 60f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 60f32, location.x);
+    assert_eq!(location.y, 10f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 10f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 40f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 40f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.x);
+    assert_eq!(location.y, 40f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 40f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 20f32, size.height);
+    assert_eq!(location.x, 60f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 60f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 20f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 0f32, location.x);
+    assert_eq!(location.y, 80f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 80f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_row_with_max_height.rs b/tests/generated/align_content_stretch_row_with_max_height.rs
new file mode 100644
index 000000000..a9f2cafab
--- /dev/null
+++ b/tests/generated/align_content_stretch_row_with_max_height.rs
@@ -0,0 +1,86 @@
+#[test]
+fn align_content_stretch_row_with_max_height() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            max_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(20f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 20f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 20f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.height);
+    assert_eq!(location.x, 100f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 100f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_row_with_min_height.rs b/tests/generated/align_content_stretch_row_with_min_height.rs
new file mode 100644
index 000000000..504be7bf1
--- /dev/null
+++ b/tests/generated/align_content_stretch_row_with_min_height.rs
@@ -0,0 +1,86 @@
+#[test]
+fn align_content_stretch_row_with_min_height() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            min_size: taffy::geometry::Size { width: auto(), height: taffy::style::Dimension::Points(80f32) },
+            ..Default::default()
+        })
+        .unwrap();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 90f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 90f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 90f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 90f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 90f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 90f32, size.height);
+    assert_eq!(location.x, 100f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 100f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 10f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.x);
+    assert_eq!(location.y, 90f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 90f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 10f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 10f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.x);
+    assert_eq!(location.y, 90f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 90f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_row_with_padding.rs b/tests/generated/align_content_stretch_row_with_padding.rs
new file mode 100644
index 000000000..432fdf878
--- /dev/null
+++ b/tests/generated/align_content_stretch_row_with_padding.rs
@@ -0,0 +1,97 @@
+#[test]
+fn align_content_stretch_row_with_padding() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            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();
+    let node2 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node3 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            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();
+    let node4 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..Default::default()
+            },
+            &[node0, node1, node2, node3, node4],
+        )
+        .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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node2).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node2.data(), 50f32, size.height);
+    assert_eq!(location.x, 100f32, "x of node {:?}. Expected {}. Actual {}", node2.data(), 100f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node2.data(), 0f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node3).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, size.height);
+    assert_eq!(location.x, 0f32, "x of node {:?}. Expected {}. Actual {}", node3.data(), 0f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node3.data(), 50f32, location.y);
+    let Layout { size, location, .. } = taffy.layout(node4).unwrap();
+    assert_eq!(size.width, 50f32, "width of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.width);
+    assert_eq!(size.height, 50f32, "height of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.x);
+    assert_eq!(location.y, 50f32, "y of node {:?}. Expected {}. Actual {}", node4.data(), 50f32, location.y);
+}
diff --git a/tests/generated/align_content_stretch_row_with_single_row.rs b/tests/generated/align_content_stretch_row_with_single_row.rs
new file mode 100644
index 000000000..4f37884f8
--- /dev/null
+++ b/tests/generated/align_content_stretch_row_with_single_row.rs
@@ -0,0 +1,52 @@
+#[test]
+fn align_content_stretch_row_with_single_row() {
+    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(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node1 = taffy
+        .new_leaf(taffy::style::Style {
+            size: taffy::geometry::Size { width: taffy::style::Dimension::Points(50f32), height: auto() },
+            ..Default::default()
+        })
+        .unwrap();
+    let node = taffy
+        .new_with_children(
+            taffy::style::Style {
+                flex_wrap: taffy::style::FlexWrap::Wrap,
+                align_content: Some(taffy::style::AlignContent::Stretch),
+                size: taffy::geometry::Size {
+                    width: taffy::style::Dimension::Points(150f32),
+                    height: taffy::style::Dimension::Points(100f32),
+                },
+                ..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, 150f32, "width of node {:?}. Expected {}. Actual {}", node.data(), 150f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node0.data(), 50f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node0.data(), 100f32, 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, 50f32, "width of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, size.width);
+    assert_eq!(size.height, 100f32, "height of node {:?}. Expected {}. Actual {}", node1.data(), 100f32, size.height);
+    assert_eq!(location.x, 50f32, "x of node {:?}. Expected {}. Actual {}", node1.data(), 50f32, location.x);
+    assert_eq!(location.y, 0f32, "y of node {:?}. Expected {}. Actual {}", node1.data(), 0f32, location.y);
+}
diff --git a/tests/generated/align_items_center_justify_content_center.rs b/tests/generated/align_items_center_justify_content_center.rs
new file mode 100644
index 000000000..e52086dce
--- /dev/null
+++ b/tests/generated/align_items_center_justify_content_center.rs
@@ -0,0 +1,95 @@
+#[test]
+fn align_items_center_justify_content_center() {
+    use slotmap::Key;
+    #[allow(unused_imports)]
+    use taffy::{layout::Layout, prelude::*};
+    let mut taffy = taffy::Taffy::new();
+    let node000 = taffy
+