tawasuyu/taffy

gentest would not build with a current openssl, due to the selenium
crate's outdated version of openssl-sys. A quick glance suggests that
it's no longer being maintained, and so I've made the switch here to
`fantoccini` which uses the newer cross-browser WebDriver API. This
crate uses async I/O for communicating with the browser, so this also
includes a dep on tokio for running the futures.

This switch (somehow?) exposed some floating point error introduced
in the test generation. In the course of debugging this issue I moved
the test codegen to use quote/proc_macro2/syn, which ended up fixing
the issue as far as I can tell (none of the off-by-one test errors
happen anymore!).

There's one test which is still marked as ignored, which will be
resolved in a followup commit.

diff --git a/Cargo.toml b/Cargo.toml
index aea1cb1cc..b26aba789 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,3 +32,6 @@ panic = 'abort'
 [[bench]]
 name = "generated"
 harness = false
+
+[workspace]
+members = [ "scripts/gentest" ]
diff --git a/README.md b/README.md
index aaeaa016e..4238d0289 100644
--- a/README.md
+++ b/README.md
@@ -44,7 +44,9 @@ brew tap homebrew/cask
 brew cask install chromedriver
 ```
 
-[Selenium](https://www.seleniumhq.org) is bundled in the repo so no need to download it. However you must ensure to have java installed first. Once you have everything installed you can re-generate all tests by running `cargo run --manifest-path scripts/gentest/Cargo.toml`. To add a new test case add another HTML file to `/test_fixtures` following the current tests as a template for new tests.
+Once you have chromedriver installed and available in `PATH` you can re-generate all tests by running `cargo run --package gentest`.
+
+To add a new test case add another HTML file to `/test_fixtures` following the current tests as a template for new tests.
 
 ## Contributing
 Contributions are very welcome. Though we ask that you open an issue or pull request early in the process (before writing code) so we can discuss solutions and additions before you start spending time on implementing them. There are some specific areas where we would be extra happy to receive contributions in.
diff --git a/scripts/gentest/Cargo.toml b/scripts/gentest/Cargo.toml
index bb5e1dfde..83573f292 100644
--- a/scripts/gentest/Cargo.toml
+++ b/scripts/gentest/Cargo.toml
@@ -5,5 +5,15 @@ authors = ["Emil Sjölander <emil@visly.app>"]
 edition = "2018"
 
 [dependencies]
-selenium-rs = "0.1.0"
+env_logger = "0.6"
+failure = "0.1"
+fantoccini = "0.11.7"
+futures = "0.1"
+indicatif = "0.11"
 json = "0.11.13"
+log = "0.4"
+proc-macro2 = "0.4"
+quote = "0.6"
+serde_json = "1"
+syn = "0.15"
+tokio = "0.1"
diff --git a/scripts/gentest/src/main.rs b/scripts/gentest/src/main.rs
index 18f5e83a4..cbe71ee36 100644
--- a/scripts/gentest/src/main.rs
+++ b/scripts/gentest/src/main.rs
@@ -1,385 +1,460 @@
-use selenium_rs::element::Element;
-use selenium_rs::webdriver::{Browser, Selector, WebDriver};
-
-use std::process::Command;
-use std::path::Path;
 use std::fs;
-use std::{thread, time};
+use std::path::{Path, PathBuf};
+use std::process::Command;
 
+use failure::*;
+use fantoccini::{Client, Locator};
+use futures::{future::Future, stream::Stream, sync::oneshot::channel};
 use json;
+use log::*;
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
+use syn::Ident;
 
 fn main() {
-    // std::env::current_exe should be <path/to/repo>/scripts/gentest/target/debug/gentest
-    // move up five times to get to repo root
-    let root_dir = std::env::current_exe().unwrap();
-    let repo_root = root_dir.parent()
-        .and_then(Path::parent)
-        .and_then(Path::parent)
-        .and_then(Path::parent)
-        .and_then(Path::parent)
-        .unwrap();
+    env_logger::init();
+    // this requires being run by cargo, which is iffy
+    let root_dir = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
+    let repo_root = root_dir.parent().and_then(Path::parent).unwrap();
 
     let fixtures_root = repo_root.join("test_fixtures");
-
-    let mut selenium = Command::new("java")
-        .arg("-jar")
-        .arg("selenium.jar")
-        .current_dir(&format!("{}/scripts/gentest", repo_root.display()))
-        .spawn()
-        .expect("failed to execute selenium, most likely missing java");
-
-    // Wait for a bit until selenium is up and running...
-    let ten_millis = time::Duration::from_millis(2000);
-    thread::sleep(ten_millis);
-
-    let mut driver = WebDriver::new(Browser::Chrome);
-    driver.start_session();
-
-    let mut src = String::new();
-    src.push_str("#[cfg(test)]\n");
-    src.push_str("mod generated {\n");
-
     let fixtures = fs::read_dir(fixtures_root).unwrap();
-    for fixture in fixtures {
-        let fixture_path = fixture.unwrap().path();
-        if fixture_path.is_file() {
-            let name = fixture_path.file_stem().unwrap().to_str().unwrap();
-
-            driver.navigate(&format!("file://{}", fixture_path.display()));
-            let root_element = driver.query_element(Selector::CSS, "#test-root").unwrap();
-            src.push_str(&format!("{}\n", generate_test(&name, root_element)));
+
+    info!("reading test fixtures from disk");
+    let mut fixtures: Vec<_> = fixtures
+        .into_iter()
+        .filter_map(|a| a.ok())
+        .filter(|f| f.path().is_file() && f.path().extension().map(|p| p == "html").unwrap_or(false))
+        .map(|f| {
+            let fixture_path = f.path().to_path_buf();
+            let name = fixture_path.file_stem().unwrap().to_str().unwrap().to_string();
+            (name, fixture_path)
+        })
+        .collect();
+    fixtures.sort_unstable_by_key(|f| f.0.clone());
+
+    info!("starting webdriver instance");
+    let webdriver_url = "http://localhost:4444";
+    let mut webdriver_handle = Command::new("chromedriver").arg("--port=4444").spawn().unwrap();
+
+    // this is silly, but it works
+    std::thread::sleep(std::time::Duration::from_secs(1));
+
+    let mut caps = serde_json::map::Map::new();
+    let chrome_opts = serde_json::json!({ "args": ["--headless", "--disable-gpu"] });
+    caps.insert("goog:chromeOptions".to_string(), chrome_opts.clone());
+
+    use indicatif::ProgressBar;
+    let pb = ProgressBar::new(fixtures.len() as u64);
+    let (test_descs_sink, mut test_descs) = channel();
+
+    info!("spawning webdriver client and collecting test descriptions");
+    tokio::run(
+        Client::with_capabilities(webdriver_url, caps.clone())
+            .map_err(|e| Error::from(e))
+            .and_then(move |client| {
+                futures::stream::iter_ok(pb.wrap_iter(fixtures.into_iter()))
+                    .and_then(move |(name, fixture_path)| {
+                        pb.set_message(&name);
+                        test_root_element(client.clone(), name, fixture_path)
+                    })
+                    .collect()
+                    .map(move |descs| {
+                        info!("finished collecting descriptions, sending them back to main");
+                        let _ = test_descs_sink.send(descs);
+                    })
+            })
+            .map_err(|e| {
+                error!("top-level error encountered: {:?}", e);
+            }),
+    );
+
+    info!("killing webdriver instance...");
+    webdriver_handle.kill().unwrap();
+
+    info!("collecting test descriptions from async runtime...");
+    let test_descs = loop {
+        if let Ok(Some(descs)) = test_descs.try_recv() {
+            break descs;
         }
+    };
+
+    info!("generating test sources and concatenating...");
+
+    let test_descs: Vec<_> = test_descs
+        .into_iter()
+        .map(|(name, description)| {
+            debug!("generating test contents for {}", &name);
+            (name.clone(), generate_test(name, description))
+        })
+        .collect();
+
+    let test_mods = test_descs
+        .iter()
+        .map(|(name, _)| {
+            let name = Ident::new(name, Span::call_site());
+            quote!(mod #name;)
+        })
+        .fold(quote!(), |a, b| quote!(#a #b));
+
+    for (name, test_body) in test_descs {
+        let mut test_filename = repo_root.join("tests").join("generated").join(&name);
+        test_filename.set_extension("rs");
+        debug!("writing {} to disk...", &name);
+        fs::write(test_filename, test_body.to_string()).unwrap();
     }
-    
-    src.push_str("}\n");
-    fs::write(repo_root.join("tests").join("generated.rs"), src);
 
-    Command::new("cargo")
-        .arg("fmt")
-        .current_dir(repo_root)
-        .status();
+    info!("writing generated test file to disk...");
+    fs::write(repo_root.join("tests").join("generated").join("mod.rs"), test_mods.to_string()).unwrap();
+    info!("formatting the source directory");
+    Command::new("cargo").arg("fmt").current_dir(repo_root).status().unwrap();
+}
 
-    driver.delete_session();
-    selenium.kill();
+fn test_root_element(
+    client: Client,
+    name: String,
+    fixture_path: impl AsRef<Path>,
+) -> impl Future<Item = (String, json::JsonValue), Error = Error> {
+    let fixture_path = fixture_path.as_ref();
+
+    let url = format!("file://{}", fixture_path.display());
+    let nav_client = client.clone();
+    let mut locate_client = client.clone();
+
+    nav_client
+        .goto(&url)
+        .map_err(|e| e.context("navigating to file"))
+        .and_then(move |_| {
+            locate_client.find(Locator::Css("#test-root")).map_err(|e| e.context("finding #test-root")).and_then(
+                |mut root| {
+                    root.attr("__stretch_description__")
+                        .map_err(|e| e.context("retrieving stretch description from test root"))
+                        .and_then(|description_string| {
+                            json::parse(&description_string.unwrap())
+                                .map(|d| (name, d))
+                                .context("parsing test description")
+                        })
+                },
+            )
+        })
+        .map_err(|c| c.into())
 }
 
-fn generate_test(name: &str, root: Element) -> String {
-    let description_string = root.get_property("__stretch_description__").unwrap();
-    let description = json::parse(&description_string).unwrap();
-
-    let mut src = String::new();
-    src.push_str("#[test]\n");
-    src.push_str(&format!("fn {}() {{\n", name));
-    
-    src.push_str("let layout = stretch::compute(\n");
-    src.push_str(&format!("&{}", &generate_node(&description)));
-    src.push_str(", stretch::geometry::Size::undefined()).unwrap();\n\n");
-
-    src.push_str(&generate_assertions("layout".to_string(), &description));
-    src.push_str("}\n");
-    src
+fn generate_test(name: impl AsRef<str>, description: json::JsonValue) -> TokenStream {
+    let ignorelist = &["flex_basis_smaller_than_content_column"];
+
+    let name = name.as_ref();
+    let maybe_ignore = if ignorelist.contains(&name) { quote!(#[ignore]) } else { quote!() };
+    let name = Ident::new(name, Span::call_site());
+    let node_description = generate_node(&description);
+    let assertions = generate_assertions(quote!(layout), &description);
+
+    quote!(
+        #[test]
+        #maybe_ignore
+        fn #name() {
+            let layout = stretch::compute(&#node_description, stretch::geometry::Size::undefined()).unwrap();
+            #assertions
+        }
+    )
 }
 
-fn generate_assertions(prefix: String, node: &json::JsonValue) -> String {
+fn generate_assertions(prefix: TokenStream, node: &json::JsonValue) -> TokenStream {
     let layout = &node["layout"];
-    let mut src = String::new();
 
-    src.push_str(&format!("assert_eq!({}.size.width, {:.4});\n", prefix, layout["width"].as_f32().unwrap()));
-    src.push_str(&format!("assert_eq!({}.size.height, {:.4});\n", prefix, layout["height"].as_f32().unwrap()));
-    src.push_str(&format!("assert_eq!({}.location.x, {:.4});\n", prefix, layout["x"].as_f32().unwrap()));
-    src.push_str(&format!("assert_eq!({}.location.y, {:.4});\n\n", prefix, layout["y"].as_f32().unwrap()));
-
-    match node["children"] {
-        json::JsonValue::Array(ref value) => {
-            for i in 0..value.len() {
-                let child = &value[i];
-                src.push_str(&generate_assertions(format!("{}.children[{}]", prefix, i), child));
+    let read_f32 = |s: &str| layout[s].as_f32().unwrap();
+    let width = read_f32("width");
+    let height = read_f32("height");
+    let x = read_f32("x");
+    let y = read_f32("y");
+
+    let children = {
+        let mut c = Vec::new();
+        match node["children"] {
+            json::JsonValue::Array(ref value) => {
+                for i in 0..value.len() {
+                    let child = &value[i];
+                    c.push(generate_assertions(quote!(#prefix.children[#i]), child));
+                }
             }
-        },
-        _ => (),
+            _ => (),
+        };
+        c.into_iter().fold(quote!(), |a, b| quote!(#a #b))
     };
-    src
-}
 
-fn generate_node(node: &json::JsonValue) -> String {
-    let mut src = String::new();
-    src.push_str("stretch::style::Node {\n");
+    quote!(
+        assert_eq!(#prefix.size.width, #width);
+        assert_eq!(#prefix.size.height, #height);
+        assert_eq!(#prefix.location.x, #x);
+        assert_eq!(#prefix.location.y, #y);
+
+        #children
+    )
+}
 
+fn generate_node(node: &json::JsonValue) -> TokenStream {
     let style = &node["style"];
 
-    match style["display"] {
-        json::JsonValue::Short(ref value) => {
-            match value.as_ref() {
-                "none" => src.push_str("display: stretch::style::Display::None,\n"),
-                _ => (),
-            };
+    let display = match style["display"] {
+        json::JsonValue::Short(ref value) => match value.as_ref() {
+            "none" => quote!(display: stretch::style::Display::None,),
+            _ => quote!(),
         },
-        _ => (),
+        _ => quote!(),
     };
 
-    match style["position_type"] {
-        json::JsonValue::Short(ref value) => {
-            match value.as_ref() {
-                "absolute" => src.push_str("position_type: stretch::style::PositionType::Absolute,\n"),
-                _ => (),
-            };
+    let position_type = match style["position_type"] {
+        json::JsonValue::Short(ref value) => match value.as_ref() {
+            "absolute" => quote!(position_type: stretch::style::PositionType::Absolute,),
+            _ => quote!(),
         },
-        _ => (),
+        _ => quote!(),
     };
 
-    match style["direction"] {
-        json::JsonValue::Short(ref value) => {
-            match value.as_ref() {
-                "rtl" => src.push_str("direction: stretch::style::Direction::RTL,\n"),
-                "ltr" => src.push_str("direction: stretch::style::Direction::LTR,\n"),
-                _ => (),
-            };
+    let direction = match style["direction"] {
+        json::JsonValue::Short(ref value) => match value.as_ref() {
+            "rtl" => quote!(direction: stretch::style::Direction::RTL,),
+            "ltr" => quote!(direction: stretch::style::Direction::LTR,),
+            _ => quote!(),
         },
-        _ => (),
+        _ => quote!(),
     };
 
-    match style["flexDirection"] {
-        json::JsonValue::Short(ref value) => {
-            match value.as_ref() {
-                "row-reverse" => src.push_str("flex_direction: stretch::style::FlexDirection::RowReverse,\n"),
-                "column" => src.push_str("flex_direction: stretch::style::FlexDirection::Column,\n"),
-                "column-reverse" => src.push_str("flex_direction: stretch::style::FlexDirection::ColumnReverse,\n"),
-                _ => (),
-            };
+    let flex_direction = match style["flexDirection"] {
+        json::JsonValue::Short(ref value) => match value.as_ref() {
+            "row-reverse" => quote!(flex_direction: stretch::style::FlexDirection::RowReverse,),
+            "column" => quote!(flex_direction: stretch::style::FlexDirection::Column,),
+            "column-reverse" => quote!(flex_direction: stretch::style::FlexDirection::ColumnReverse,),
+            _ => quote!(),
         },
-        _ => (),
+        _ => quote!(),
     };
 
-    match style["flexWrap"] {
-        json::JsonValue::Short(ref value) => {
-            match value.as_ref() {
-                "wrap" => src.push_str("flex_wrap: stretch::style::FlexWrap::Wrap,\n"),
-                "wrap-reverse" => src.push_str("flex_wrap: stretch::style::FlexWrap::WrapReverse,\n"),
-                _ => (),
-            };
+    let flex_wrap = match style["flexWrap"] {
+        json::JsonValue::Short(ref value) => match value.as_ref() {
+            "wrap" => quote!(flex_wrap: stretch::style::FlexWrap::Wrap,),
+            "wrap-reverse" => quote!(flex_wrap: stretch::style::FlexWrap::WrapReverse,),
+            _ => quote!(),
         },
-        _ => (),
+        _ => quote!(),
     };
 
-    match style["overflow"] {
-        json::JsonValue::Short(ref value) => {
-            match value.as_ref() {
-                "hidden" => src.push_str("overflow: stretch::style::Overflow::Hidden,\n"),
-                "scroll" => src.push_str("overflow: stretch::style::Overflow::Scroll,\n"),
-                _ => (),
-            };
+    let overflow = match style["overflow"] {
+        json::JsonValue::Short(ref value) => match value.as_ref() {
+            "hidden" => quote!(overflow: stretch::style::Overflow::Hidden,),
+            "scroll" => quote!(overflow: stretch::style::Overflow::Scroll,),
+            _ => quote!(),
         },
-        _ => (),
+        _ => quote!(),
     };
 
-    match style["alignItems"] {
-        json::JsonValue::Short(ref value) => {
-            match value.as_ref() {
-                "flex-start" => src.push_str("align_items: stretch::style::AlignItems::FlexStart,\n"),
-                "flex-end" => src.push_str("align_items: stretch::style::AlignItems::FlexEnd,\n"),
-                "center" => src.push_str("align_items: stretch::style::AlignItems::Center,\n"),
-                "baseline" => src.push_str("align_items: stretch::style::AlignItems::Baseline,\n"),
-                _ => (),
-            };
+    let align_items = match style["alignItems"] {
+        json::JsonValue::Short(ref value) => match value.as_ref() {
+            "flex-start" => quote!(align_items: stretch::style::AlignItems::FlexStart,),
+            "flex-end" => quote!(align_items: stretch::style::AlignItems::FlexEnd,),
+            "center" => quote!(align_items: stretch::style::AlignItems::Center,),
+            "baseline" => quote!(align_items: stretch::style::AlignItems::Baseline,),
+            _ => quote!(),
         },
-        _ => (),
+        _ => quote!(),
     };
 
-    match style["alignSelf"] {
-        json::JsonValue::Short(ref value) => {
-            match value.as_ref() {
-                "flex-start" => src.push_str("align_self: stretch::style::AlignSelf::FlexStart,\n"),
-                "flex-end" => src.push_str("align_self: stretch::style::AlignSelf::FlexEnd,\n"),
-                "center" => src.push_str("align_self: stretch::style::AlignSelf::Center,\n"),
-                "baseline" => src.push_str("align_self: stretch::style::AlignSelf::Baseline,\n"),
-                "stretch" => src.push_str("align_self: stretch::style::AlignSelf::Stretch,\n"),
-                _ => (),
-            };
+    let align_self = match style["alignSelf"] {
+        json::JsonValue::Short(ref value) => match value.as_ref() {
+            "flex-start" => quote!(align_self: stretch::style::AlignSelf::FlexStart,),
+            "flex-end" => quote!(align_self: stretch::style::AlignSelf::FlexEnd,),
+            "center" => quote!(align_self: stretch::style::AlignSelf::Center,),
+            "baseline" => quote!(align_self: stretch::style::AlignSelf::Baseline,),
+            "stretch" => quote!(align_self: stretch::style::AlignSelf::Stretch,),
+            _ => quote!(),
         },
-        _ => (),
+        _ => quote!(),
     };
 
-    match style["alignContent"] {
-        json::JsonValue::Short(ref value) => {
-            match value.as_ref() {
-                "flex-start" => src.push_str("align_content: stretch::style::AlignContent::FlexStart,\n"),
-                "flex-end" => src.push_str("align_content: stretch::style::AlignContent::FlexEnd,\n"),
-                "center" => src.push_str("align_content: stretch::style::AlignContent::Center,\n"),
-                "space-between" => src.push_str("align_content: stretch::style::AlignContent::SpaceBetween,\n"),
-                "space-around" => src.push_str("align_content: stretch::style::AlignContent::SpaceAround,\n"),
-                _ => (),
-            };
+    let align_content = match style["alignContent"] {
+        json::JsonValue::Short(ref value) => match value.as_ref() {
+            "flex-start" => quote!(align_content: stretch::style::AlignContent::FlexStart,),
+            "flex-end" => quote!(align_content: stretch::style::AlignContent::FlexEnd,),
+            "center" => quote!(align_content: stretch::style::AlignContent::Center,),
+            "space-between" => quote!(align_content: stretch::style::AlignContent::SpaceBetween,),
+            "space-around" => quote!(align_content: stretch::style::AlignContent::SpaceAround,),
+            _ => quote!(),
         },
-        _ => (),
+        _ => quote!(),
     };
 
-    match style["justifyContent"] {
-        json::JsonValue::Short(ref value) => {
-            match value.as_ref() {
-                "flex-end" => src.push_str("justify_content: stretch::style::JustifyContent::FlexEnd,\n"),
-                "center" => src.push_str("justify_content: stretch::style::JustifyContent::Center,\n"),
-                "space-between" => src.push_str("justify_content: stretch::style::JustifyContent::SpaceBetween,\n"),
-                "space-around" => src.push_str("justify_content: stretch::style::JustifyContent::SpaceAround,\n"),
-                "space-evenly" => src.push_str("justify_content: stretch::style::JustifyContent::SpaceEvenly,\n"),
-                _ => (),
-            };
+    let justify_content = match style["justifyContent"] {
+        json::JsonValue::Short(ref value) => match value.as_ref() {
+            "flex-end" => quote!(justify_content: stretch::style::JustifyContent::FlexEnd,),
+            "center" => quote!(justify_content: stretch::style::JustifyContent::Center,),
+            "space-between" => quote!(justify_content: stretch::style::JustifyContent::SpaceBetween,),
+            "space-around" => quote!(justify_content: stretch::style::JustifyContent::SpaceAround,),
+            "space-evenly" => quote!(justify_content: stretch::style::JustifyContent::SpaceEvenly,),
+            _ => quote!(),
         },
-        _ => (),
+        _ => quote!(),
     };
 
-    match style["flexGrow"] {
+    let flex_grow = match style["flexGrow"] {
         json::JsonValue::Number(value) => {
             let value: f32 = value.into();
-            src.push_str(&format!("flex_grow: {:.4},\n", value))
-        },
-        _ => (),
+            quote!(flex_grow: #value,)
+        }
+        _ => quote!(),
     };
 
-    match style["flexShrink"] {
+    let flex_shrink = match style["flexShrink"] {
         json::JsonValue::Number(value) => {
             let value: f32 = value.into();
-            src.push_str(&format!("flex_shrink: {:.4},\n", value))
-        },
-        _ => (),
-    };
-
-    match style["flexBasis"] {
-        json::JsonValue::Object(ref value) => src.push_str(&format!("flex_basis: {},\n", generate_dimension(value))),
-        _ => (),
-    };
-
-    match style["size"] {
-        json::JsonValue::Object(ref value) => src.push_str(&format!("size: {},\n", generate_size(value))),
-        _ => (),
+            quote!(flex_shrink: #value,)
+        }
+        _ => quote!(),
     };
 
-    match style["min_size"] {
-        json::JsonValue::Object(ref value) => src.push_str(&format!("min_size: {},\n", generate_size(value))),
-        _ => (),
+    let flex_basis = match style["flexBasis"] {
+        json::JsonValue::Object(ref value) => {
+            let value = generate_dimension(value);
+            quote!(flex_basis: #value,)
+        }
+        _ => quote!(),
     };
 
-    match style["max_size"] {
-        json::JsonValue::Object(ref value) => src.push_str(&format!("max_size: {},\n", generate_size(value))),
-        _ => (),
+    let size = match style["size"] {
+        json::JsonValue::Object(ref value) => {
+            let size = generate_size(value);
+            quote!(size: #size,)
+        }
+        _ => quote!(),
     };
 
-    match style["margin"] {
-        json::JsonValue::Object(ref value) => src.push_str(&format!("margin: {},\n", generate_edges(value))),
-        _ => (),
+    let min_size = match style["min_size"] {
+        json::JsonValue::Object(ref value) => {
+            let min_size = generate_size(value);
+            quote!(min_size: #min_size,)
+        }
+        _ => quote!(),
     };
 
-    match style["padding"] {
-        json::JsonValue::Object(ref value) => src.push_str(&format!("padding: {},\n", generate_edges(value))),
-        _ => (),
+    let max_size = match style["max_size"] {
+        json::JsonValue::Object(ref value) => {
+            let max_size = generate_size(value);
+            quote!(max_size: #max_size,)
+        }
+        _ => quote!(),
     };
 
-    match style["position"] {
-        json::JsonValue::Object(ref value) => src.push_str(&format!("position: {},\n", generate_edges(value))),
-        _ => (),
-    };
+    macro_rules! edges_quoted {
+        ($style:ident, $val:ident) => {
+            let $val = match $style[stringify!($val)] {
+                json::JsonValue::Object(ref value) => {
+                    let edges = generate_edges(value);
+                    quote!($val: #edges,)
+                },
+                _ => quote!(),
+            };
+        };
+    }
 
-    match style["border"] {
-        json::JsonValue::Object(ref value) => src.push_str(&format!("border: {},\n", generate_edges(value))),
-        _ => (),
-    };
+    edges_quoted!(style, margin);
+    edges_quoted!(style, padding);
+    edges_quoted!(style, position);
+    edges_quoted!(style, border);
 
-    match node["children"] {
+    let children = match node["children"] {
         json::JsonValue::Array(ref value) => {
             if value.len() > 0 {
-                src.push_str("children: vec![\n");
-                value.iter().for_each(|child| {
-                    src.push_str(&format!("{},\n", generate_node(child)));
+                let body = value.iter().fold(quote!(), |prev, child| {
+                    let child = generate_node(child);
+                    quote!(#prev #child,)
                 });
-                src.push_str("],\n");
+                quote!(children: vec![ #body ],)
+            } else {
+                quote!()
             }
-        },
-        _ => (),
+        }
+        _ => quote!(),
     };
 
-    src.push_str("..Default::default()\n");
-    src.push_str("}\n");
-    src
+    quote!(stretch::style::Node {
+        #display
+        #direction
+        #position_type
+        #flex_direction
+        #flex_wrap
+        #overflow
+        #align_items
+        #align_self
+        #align_content
+        #justify_content
+        #flex_grow
+        #flex_shrink
+        #flex_basis
+        #size
+        #min_size
+        #max_size
+
+        #children
+
+        #margin
+        #padding
+        #position
+        #border
+        ..Default::default()
+    })
 }
 
-fn generate_size(size: &json::object::Object) -> String {
-    let mut src = String::new();
-    src.push_str("stretch::geometry::Size {\n");
-
-    match size.get("width") {
-        Some(value) => match value {
-            json::JsonValue::Object(ref value) => src.push_str(&format!("width: {},\n", generate_dimension(value))),
-            _ => (),
-        },
-        None => (),
-    };
-
-    match size.get("height") {
-        Some(value) => match value {
-            json::JsonValue::Object(ref value) => src.push_str(&format!("height: {},\n", generate_dimension(value))),
-            _ => (),
-        },
-        None => (),
+macro_rules! dim_quoted {
+    ($obj:ident, $dim_name:ident) => {
+        let $dim_name = match $obj.get(stringify!($dim_name)) {
+            Some(json::JsonValue::Object(ref value)) => {
+                let dim = generate_dimension(value);
+                quote!($dim_name: #dim,)
+            }
+            _ => quote!(),
+        };
     };
+}
 
-    src.push_str("..Default::default()\n");
-    src.push_str("}\n");
-    src
+fn generate_size(size: &json::object::Object) -> TokenStream {
+    dim_quoted!(size, width);
+    dim_quoted!(size, height);
+    quote!(
+        stretch::geometry::Size {
+            #width #height
+            ..Default::default()
+        }
+    )
 }
 
-fn generate_dimension(dimen: &json::object::Object) -> String {
+fn generate_dimension(dimen: &json::object::Object) -> TokenStream {
     let unit = dimen.get("unit").unwrap();
     let value = || dimen.get("value").unwrap().as_f32().unwrap();
 
     match unit {
-        json::JsonValue::Short(ref unit) => {
-            match unit.as_ref() {
-                "auto" => format!("stretch::style::Dimension::Auto"),
-                "points" => format!("stretch::style::Dimension::Points({:.4})", value()),
-                "percent" => format!("stretch::style::Dimension::Percent({:.4})", value()),
-                _ => panic!(),
+        json::JsonValue::Short(ref unit) => match unit.as_ref() {
+            "auto" => quote!(stretch::style::Dimension::Auto),
+            "points" => {
+                let value = value();
+                quote!(stretch::style::Dimension::Points(#value))
+            }
+            "percent" => {
+                let value = value();
+                quote!(stretch::style::Dimension::Percent(#value))
             }
+            _ => unreachable!(),
         },
-        _ => panic!(),
+        _ => unreachable!(),
     }
 }
 
-fn generate_edges(dimen: &json::object::Object) -> String {
-    let mut src = String::new();
-    src.push_str("stretch::geometry::Rect {\n");
-
-    match dimen.get("start") {
-        Some(value) => match value {
-            json::JsonValue::Object(ref value) => src.push_str(&format!("start: {},\n", generate_dimension(value))),
-            _ => (),
-        },
-        None => (),
-    };
-
-    match dimen.get("end") {
-        Some(value) => match value {
-            json::JsonValue::Object(ref value) => src.push_str(&format!("end: {},\n", generate_dimension(value))),
-            _ => (),
-        },
-        None => (),
-    };
-
-    match dimen.get("top") {
-        Some(value) => match value {
-            json::JsonValue::Object(ref value) => src.push_str(&format!("top: {},\n", generate_dimension(value))),
-            _ => (),
-        },
-        None => (),
-    };
-
-    match dimen.get("bottom") {
-        Some(value) => match value {
-            json::JsonValue::Object(ref value) => src.push_str(&format!("bottom: {},\n", generate_dimension(value))),
-            _ => (),
-        },
-        None => (),
-    };
+fn generate_edges(dimen: &json::object::Object) -> TokenStream {
+    dim_quoted!(dimen, start);
+    dim_quoted!(dimen, end);
+    dim_quoted!(dimen, top);
+    dim_quoted!(dimen, bottom);
 
-    src.push_str("..Default::default()\n");
-    src.push_str("}\n");
-    src
+    quote!(stretch::geometry::Rect {
+        #start #end #top #bottom
+        ..Default::default()
+    })
 }
diff --git a/tests/fixtures.rs b/tests/fixtures.rs
new file mode 100644
index 000000000..904388cb7
--- /dev/null
+++ b/tests/fixtures.rs
@@ -0,0 +1,4 @@
+// this declaration is necessary to "mount" the generated code where cargo can see it
+// this allows us to both keep code generation scoped to a singe directory for fs events
+// and to keep each test in a separate file
+mod generated;
diff --git a/tests/generated.rs b/tests/generated.rs
deleted file mode 100644
index 6827431c7..000000000
--- a/tests/generated.rs
+++ /dev/null
@@ -1,240 +0,0 @@
-mod generated {
-    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;
-    mod absolute_layout_align_items_and_justify_content_center_and_right_position;
-    mod absolute_layout_align_items_and_justify_content_center_and_top_position;
-    mod absolute_layout_align_items_and_justify_content_flex_end;
-    mod absolute_layout_align_items_center;
-    mod absolute_layout_align_items_center_on_child_only;
-    mod absolute_layout_child_order;
-    mod absolute_layout_in_wrap_reverse_column_container;
-    mod absolute_layout_in_wrap_reverse_column_container_flex_end;
-    mod absolute_layout_in_wrap_reverse_row_container;
-    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_start_top_end_bottom;
-    mod absolute_layout_width_height_end_bottom;
-    mod absolute_layout_width_height_start_top;
-    mod absolute_layout_width_height_start_top_end_bottom;
-    mod absolute_layout_within_border;
-    mod align_baseline;
-    mod align_baseline_child_multiline;
-    mod align_baseline_nested_child;
-    mod align_center_should_size_based_on_content;
-    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_with_child_margin;
-    mod align_items_center_with_child_top;
-    mod align_items_flex_end;
-    mod align_items_flex_end_child_with_margin_bigger_than_parent;
-    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_self_baseline;
-    mod align_self_center;
-    mod align_self_flex_end;
-    mod align_self_flex_end_override_flex_start;
-    mod align_self_flex_start;
-    mod align_strech_should_size_based_on_parent;
-    mod border_center_child;
-    mod border_flex_child;
-    mod border_no_child;
-    mod border_stretch_child;
-    mod child_min_max_width_flexing;
-    mod container_with_unsized_child;
-    mod display_none;
-    mod display_none_fixed_size;
-    mod display_none_with_child;
-    mod display_none_with_margin;
-    mod display_none_with_position;
-    mod flex_basis_and_main_dimen_set_when_flexing;
-    mod flex_basis_flex_grow_column;
-    mod flex_basis_flex_grow_row;
-    mod flex_basis_flex_shrink_column;
-    mod flex_basis_flex_shrink_row;
-    mod flex_basis_larger_than_content_column;
-    mod flex_basis_larger_than_content_row;
-    mod flex_basis_overrides_main_size;
-    mod flex_basis_slightly_smaller_then_content_with_flex_grow_large_size;
-    mod flex_basis_smaller_than_content_column;
-    mod flex_basis_smaller_than_content_row;
-    mod flex_basis_smaller_than_main_dimen_column;
-    mod flex_basis_smaller_than_main_dimen_row;
-    mod flex_basis_smaller_then_content_with_flex_grow_large_size;
-    mod flex_basis_smaller_then_content_with_flex_grow_small_size;
-    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_direction_column;
-    mod flex_direction_column_no_height;
-    mod flex_direction_column_reverse;
-    mod flex_direction_row;
-    mod flex_direction_row_no_width;
-    mod flex_direction_row_reverse;
-    mod flex_grow_child;
-    mod flex_grow_flex_basis_percent_min_max;
-    mod flex_grow_height_maximized;
-    mod flex_grow_in_at_most_container;
-    mod flex_grow_less_than_factor_one;
-    mod flex_grow_root_minimized;
-    mod flex_grow_shrink_at_most;
-    mod flex_grow_to_min;
-    mod flex_grow_within_constrained_max_column;
-    mod flex_grow_within_constrained_max_row;
-    mod flex_grow_within_constrained_max_width;
-    mod flex_grow_within_constrained_min_column;
-    mod flex_grow_within_constrained_min_max_column;
-    mod flex_grow_within_constrained_min_row;
-    mod flex_grow_within_max_width;
-    mod flex_root_ignored;
-    mod flex_shrink_by_outer_margin_with_max_size;
-    mod flex_shrink_flex_grow_child_flex_shrink_other_child;
-    mod flex_shrink_flex_grow_row;
-    mod flex_shrink_to_zero;
-    mod flex_wrap_align_stretch_fits_one_row;
-    mod flex_wrap_children_with_min_main_overriding_flex_basis;
-    mod flex_wrap_wrap_to_child_height;
-    mod justify_content_column_center;
-    mod justify_content_column_flex_end;
-    mod justify_content_column_flex_start;
-    mod justify_content_column_min_height_and_margin_bottom;
-    mod justify_content_column_min_height_and_margin_top;
-    mod justify_content_column_space_around;
-    mod justify_content_column_space_between;
-    mod justify_content_column_space_evenly;
-    mod justify_content_min_max;
-    mod justify_content_min_width_with_padding_child_width_greater_than_parent;
-    mod justify_content_min_width_with_padding_child_width_lower_than_parent;
-    mod justify_content_overflow_min_max;
-    mod justify_content_row_center;
-    mod justify_content_row_flex_end;
-    mod justify_content_row_flex_start;
-    mod justify_content_row_max_width_and_margin;
-    mod justify_content_row_min_width_and_margin;
-    mod justify_content_row_space_around;
-    mod justify_content_row_space_between;
-    mod justify_content_row_space_evenly;
-    mod margin_and_flex_column;
-    mod margin_and_flex_row;
-    mod margin_and_stretch_column;
-    mod margin_and_stretch_row;
-    mod margin_auto_bottom;
-    mod margin_auto_bottom_and_top;
-    mod margin_auto_bottom_and_top_justify_center;
-    mod margin_auto_left;
-    mod margin_auto_left_and_right;
-    mod margin_auto_left_and_right_column;
-    mod margin_auto_left_and_right_column_and_center;
-    mod margin_auto_left_and_right_strech;
-    mod margin_auto_left_child_bigger_than_parent;
-    mod margin_auto_left_fix_right_child_bigger_than_parent;
-    mod margin_auto_left_right_child_bigger_than_parent;
-    mod margin_auto_left_stretching_child;
-    mod margin_auto_mutiple_children_column;
-    mod margin_auto_mutiple_children_row;
-    mod margin_auto_right;
-    mod margin_auto_top;
-    mod margin_auto_top_and_bottom_strech;
-    mod margin_auto_top_stretching_child;
-    mod margin_bottom;
-    mod margin_fix_left_auto_right_child_bigger_than_parent;
-    mod margin_left;
-    mod margin_right;
-    mod margin_should_not_be_part_of_max_height;
-    mod margin_should_not_be_part_of_max_width;
-    mod margin_top;
-    mod margin_with_sibling_column;
-    mod margin_with_sibling_row;
-    mod max_height;
-    mod max_height_overrides_height;
-    mod max_height_overrides_height_on_root;
-    mod max_width;
-    mod max_width_overrides_width;
-    mod max_width_overrides_width_on_root;
-    mod min_height;
-    mod min_height_overrides_height;
-    mod min_height_overrides_height_on_root;
-    mod min_max_percent_no_width_height;
-    mod min_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 overflow_cross_axis;
-    mod overflow_main_axis;
-    mod padding_align_end_child;
-    mod padding_center_child;
-    mod padding_flex_child;
-    mod padding_no_child;
-    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_flex_basis;
-    mod percentage_flex_basis_cross;
-    mod percentage_flex_basis_cross_max_height;
-    mod percentage_flex_basis_cross_max_width;
-    mod percentage_flex_basis_cross_min_height;
-    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_margin_should_calculate_based_only_on_width;
-    mod percentage_multiple_nested_with_padding_margin_and_percentage_values;
-    mod percentage_padding_should_calculate_based_only_on_width;
-    mod percentage_position_bottom_right;
-    mod percentage_position_left_top;
-    mod percentage_size_based_on_parent_inner_size;
-    mod percentage_size_of_flex_basis;
-    mod percentage_width_height;
-    mod percentage_width_height_undefined_parent_size;
-    mod relative_position_should_not_nudge_siblings;
-    mod rounding_flex_basis_flex_grow_row_prime_number_width;
-    mod rounding_flex_basis_flex_grow_row_width_of_100;
-    mod rounding_flex_basis_flex_shrink_row;
-    mod rounding_flex_basis_overrides_main_size;
-    mod rounding_fractial_input_1;
-    mod rounding_fractial_input_2;
-    mod rounding_fractial_input_3;
-    mod rounding_fractial_input_4;
-    mod rounding_total_fractial;
-    mod rounding_total_fractial_nested;
-    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 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_column;
-    mod wrap_nodes_with_content_sizing_margin_cross;
-    mod wrap_nodes_with_content_sizing_overflowing_margin;
-    mod wrap_reverse_column;
-    mod wrap_reverse_column_fixed_size;
-    mod wrap_reverse_row;
-    mod wrap_reverse_row_align_content_center;
-    mod wrap_reverse_row_align_content_flex_start;
-    mod wrap_reverse_row_align_content_space_around;
-    mod wrap_reverse_row_align_content_stretch;
-    mod wrap_reverse_row_single_line_different_size;
-    mod wrap_row;
-    mod wrap_row_align_items_center;
-    mod wrap_row_align_items_flex_end;
-    mod wrapped_column_max_height;
-    mod wrapped_column_max_height_flex;
-    mod wrapped_row_within_align_items_center;
-    mod wrapped_row_within_align_items_flex_end;
-    mod wrapped_row_within_align_items_flex_start;
-}
diff --git a/tests/generated/absolute_layout_align_items_and_justify_content_center.rs b/tests/generated/absolute_layout_align_items_and_justify_content_center.rs
index f72f27232..a692f5d4c 100644
--- a/tests/generated/absolute_layout_align_items_and_justify_content_center.rs
+++ b/tests/generated/absolute_layout_align_items_and_justify_content_center.rs
@@ -5,15 +5,15 @@ fn absolute_layout_align_items_and_justify_content_center() {
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(110.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(110f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(60.0000),
-                    height: stretch::style::Dimension::Points(40.0000),
+                    width: stretch::style::Dimension::Points(60f32),
+                    height: stretch::style::Dimension::Points(40f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -23,14 +23,12 @@ fn absolute_layout_align_items_and_justify_content_center() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 110.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 40.0000);
-    assert_eq!(layout.children[0].location.x, 25.0000);
-    assert_eq!(layout.children[0].location.y, 30.0000);
+    assert_eq!(layout.size.width, 110f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 40f32);
+    assert_eq!(layout.children[0usize].location.x, 25f32);
+    assert_eq!(layout.children[0usize].location.y, 30f32);
 }
diff --git a/tests/generated/absolute_layout_align_items_and_justify_content_center_and_bottom_position.rs b/tests/generated/absolute_layout_align_items_and_justify_content_center_and_bottom_position.rs
index cbd855939..d062a1642 100644
--- a/tests/generated/absolute_layout_align_items_and_justify_content_center_and_bottom_position.rs
+++ b/tests/generated/absolute_layout_align_items_and_justify_content_center_and_bottom_position.rs
@@ -5,19 +5,19 @@ fn absolute_layout_align_items_and_justify_content_center_and_bottom_position()
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(110.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(110f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(60.0000),
-                    height: stretch::style::Dimension::Points(40.0000),
+                    width: stretch::style::Dimension::Points(60f32),
+                    height: stretch::style::Dimension::Points(40f32),
                     ..Default::default()
                 },
                 position: stretch::geometry::Rect {
-                    bottom: stretch::style::Dimension::Points(10.0000),
+                    bottom: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -27,14 +27,12 @@ fn absolute_layout_align_items_and_justify_content_center_and_bottom_position()
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 110.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 40.0000);
-    assert_eq!(layout.children[0].location.x, 25.0000);
-    assert_eq!(layout.children[0].location.y, 50.0000);
+    assert_eq!(layout.size.width, 110f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 40f32);
+    assert_eq!(layout.children[0usize].location.x, 25f32);
+    assert_eq!(layout.children[0usize].location.y, 50f32);
 }
diff --git a/tests/generated/absolute_layout_align_items_and_justify_content_center_and_left_position.rs b/tests/generated/absolute_layout_align_items_and_justify_content_center_and_left_position.rs
index 7ad510fda..3d319251c 100644
--- a/tests/generated/absolute_layout_align_items_and_justify_content_center_and_left_position.rs
+++ b/tests/generated/absolute_layout_align_items_and_justify_content_center_and_left_position.rs
@@ -5,19 +5,19 @@ fn absolute_layout_align_items_and_justify_content_center_and_left_position() {
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(110.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(110f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(60.0000),
-                    height: stretch::style::Dimension::Points(40.0000),
+                    width: stretch::style::Dimension::Points(60f32),
+                    height: stretch::style::Dimension::Points(40f32),
                     ..Default::default()
                 },
                 position: stretch::geometry::Rect {
-                    start: stretch::style::Dimension::Points(5.0000),
+                    start: stretch::style::Dimension::Points(5f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -27,14 +27,12 @@ fn absolute_layout_align_items_and_justify_content_center_and_left_position() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 110.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 40.0000);
-    assert_eq!(layout.children[0].location.x, 5.0000);
-    assert_eq!(layout.children[0].location.y, 30.0000);
+    assert_eq!(layout.size.width, 110f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 40f32);
+    assert_eq!(layout.children[0usize].location.x, 5f32);
+    assert_eq!(layout.children[0usize].location.y, 30f32);
 }
diff --git a/tests/generated/absolute_layout_align_items_and_justify_content_center_and_right_position.rs b/tests/generated/absolute_layout_align_items_and_justify_content_center_and_right_position.rs
index 3c38d90d2..f761a572b 100644
--- a/tests/generated/absolute_layout_align_items_and_justify_content_center_and_right_position.rs
+++ b/tests/generated/absolute_layout_align_items_and_justify_content_center_and_right_position.rs
@@ -5,19 +5,19 @@ fn absolute_layout_align_items_and_justify_content_center_and_right_position() {
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(110.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(110f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(60.0000),
-                    height: stretch::style::Dimension::Points(40.0000),
+                    width: stretch::style::Dimension::Points(60f32),
+                    height: stretch::style::Dimension::Points(40f32),
                     ..Default::default()
                 },
                 position: stretch::geometry::Rect {
-                    end: stretch::style::Dimension::Points(5.0000),
+                    end: stretch::style::Dimension::Points(5f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -27,14 +27,12 @@ fn absolute_layout_align_items_and_justify_content_center_and_right_position() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 110.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 40.0000);
-    assert_eq!(layout.children[0].location.x, 45.0000);
-    assert_eq!(layout.children[0].location.y, 30.0000);
+    assert_eq!(layout.size.width, 110f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 40f32);
+    assert_eq!(layout.children[0usize].location.x, 45f32);
+    assert_eq!(layout.children[0usize].location.y, 30f32);
 }
diff --git a/tests/generated/absolute_layout_align_items_and_justify_content_center_and_top_position.rs b/tests/generated/absolute_layout_align_items_and_justify_content_center_and_top_position.rs
index 3c8265da3..3b6765330 100644
--- a/tests/generated/absolute_layout_align_items_and_justify_content_center_and_top_position.rs
+++ b/tests/generated/absolute_layout_align_items_and_justify_content_center_and_top_position.rs
@@ -5,19 +5,19 @@ fn absolute_layout_align_items_and_justify_content_center_and_top_position() {
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(110.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(110f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(60.0000),
-                    height: stretch::style::Dimension::Points(40.0000),
+                    width: stretch::style::Dimension::Points(60f32),
+                    height: stretch::style::Dimension::Points(40f32),
                     ..Default::default()
                 },
                 position: stretch::geometry::Rect {
-                    top: stretch::style::Dimension::Points(10.0000),
+                    top: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -27,14 +27,12 @@ fn absolute_layout_align_items_and_justify_content_center_and_top_position() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 110.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 40.0000);
-    assert_eq!(layout.children[0].location.x, 25.0000);
-    assert_eq!(layout.children[0].location.y, 10.0000);
+    assert_eq!(layout.size.width, 110f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 40f32);
+    assert_eq!(layout.children[0usize].location.x, 25f32);
+    assert_eq!(layout.children[0usize].location.y, 10f32);
 }
diff --git a/tests/generated/absolute_layout_align_items_and_justify_content_flex_end.rs b/tests/generated/absolute_layout_align_items_and_justify_content_flex_end.rs
index 2c72343eb..94bd688a0 100644
--- a/tests/generated/absolute_layout_align_items_and_justify_content_flex_end.rs
+++ b/tests/generated/absolute_layout_align_items_and_justify_content_flex_end.rs
@@ -5,15 +5,15 @@ fn absolute_layout_align_items_and_justify_content_flex_end() {
             align_items: stretch::style::AlignItems::FlexEnd,
             justify_content: stretch::style::JustifyContent::FlexEnd,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(110.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(110f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(60.0000),
-                    height: stretch::style::Dimension::Points(40.0000),
+                    width: stretch::style::Dimension::Points(60f32),
+                    height: stretch::style::Dimension::Points(40f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -23,14 +23,12 @@ fn absolute_layout_align_items_and_justify_content_flex_end() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 110.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 40.0000);
-    assert_eq!(layout.children[0].location.x, 50.0000);
-    assert_eq!(layout.children[0].location.y, 60.0000);
+    assert_eq!(layout.size.width, 110f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 40f32);
+    assert_eq!(layout.children[0usize].location.x, 50f32);
+    assert_eq!(layout.children[0usize].location.y, 60f32);
 }
diff --git a/tests/generated/absolute_layout_align_items_center.rs b/tests/generated/absolute_layout_align_items_center.rs
index cda0c7fc3..600bb1fbe 100644
--- a/tests/generated/absolute_layout_align_items_center.rs
+++ b/tests/generated/absolute_layout_align_items_center.rs
@@ -4,15 +4,15 @@ fn absolute_layout_align_items_center() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(110.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(110f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(60.0000),
-                    height: stretch::style::Dimension::Points(40.0000),
+                    width: stretch::style::Dimension::Points(60f32),
+                    height: stretch::style::Dimension::Points(40f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -22,14 +22,12 @@ fn absolute_layout_align_items_center() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 110.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 40.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 30.0000);
+    assert_eq!(layout.size.width, 110f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 40f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 30f32);
 }
diff --git a/tests/generated/absolute_layout_align_items_center_on_child_only.rs b/tests/generated/absolute_layout_align_items_center_on_child_only.rs
index 0a25afa25..f3e2c1d4e 100644
--- a/tests/generated/absolute_layout_align_items_center_on_child_only.rs
+++ b/tests/generated/absolute_layout_align_items_center_on_child_only.rs
@@ -3,16 +3,16 @@ fn absolute_layout_align_items_center_on_child_only() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(110.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(110f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 align_self: stretch::style::AlignSelf::Center,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(60.0000),
-                    height: stretch::style::Dimension::Points(40.0000),
+                    width: stretch::style::Dimension::Points(60f32),
+                    height: stretch::style::Dimension::Points(40f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -22,14 +22,12 @@ fn absolute_layout_align_items_center_on_child_only() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 110.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 40.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 30.0000);
+    assert_eq!(layout.size.width, 110f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 40f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 30f32);
 }
diff --git a/tests/generated/absolute_layout_child_order.rs b/tests/generated/absolute_layout_child_order.rs
index 4d0ec901a..fb83a9228 100644
--- a/tests/generated/absolute_layout_child_order.rs
+++ b/tests/generated/absolute_layout_child_order.rs
@@ -5,15 +5,15 @@ fn absolute_layout_child_order() {
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(110.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(110f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(60.0000),
-                        height: stretch::style::Dimension::Points(40.0000),
+                        width: stretch::style::Dimension::Points(60f32),
+                        height: stretch::style::Dimension::Points(40f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -21,16 +21,16 @@ fn absolute_layout_child_order() {
                 stretch::style::Node {
                     position_type: stretch::style::PositionType::Absolute,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(60.0000),
-                        height: stretch::style::Dimension::Points(40.0000),
+                        width: stretch::style::Dimension::Points(60f32),
+                        height: stretch::style::Dimension::Points(40f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(60.0000),
-                        height: stretch::style::Dimension::Points(40.0000),
+                        width: stretch::style::Dimension::Points(60f32),
+                        height: stretch::style::Dimension::Points(40f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -41,24 +41,20 @@ fn absolute_layout_child_order() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 110.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 55.0000);
-    assert_eq!(layout.children[0].size.height, 40.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 30.0000);
-
-    assert_eq!(layout.children[1].size.width, 60.0000);
-    assert_eq!(layout.children[1].size.height, 40.0000);
-    assert_eq!(layout.children[1].location.x, 25.0000);
-    assert_eq!(layout.children[1].location.y, 30.0000);
-
-    assert_eq!(layout.children[2].size.width, 55.0000);
-    assert_eq!(layout.children[2].size.height, 40.0000);
-    assert_eq!(layout.children[2].location.x, 55.0000);
-    assert_eq!(layout.children[2].location.y, 30.0000);
+    assert_eq!(layout.size.width, 110f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 55f32);
+    assert_eq!(layout.children[0usize].size.height, 40f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 30f32);
+    assert_eq!(layout.children[1usize].size.width, 60f32);
+    assert_eq!(layout.children[1usize].size.height, 40f32);
+    assert_eq!(layout.children[1usize].location.x, 25f32);
+    assert_eq!(layout.children[1usize].location.y, 30f32);
+    assert_eq!(layout.children[2usize].size.width, 55f32);
+    assert_eq!(layout.children[2usize].size.height, 40f32);
+    assert_eq!(layout.children[2usize].location.x, 55f32);
+    assert_eq!(layout.children[2usize].location.y, 30f32);
 }
diff --git a/tests/generated/absolute_layout_in_wrap_reverse_column_container.rs b/tests/generated/absolute_layout_in_wrap_reverse_column_container.rs
index 0e029c25e..33b33d49f 100644
--- a/tests/generated/absolute_layout_in_wrap_reverse_column_container.rs
+++ b/tests/generated/absolute_layout_in_wrap_reverse_column_container.rs
@@ -5,15 +5,15 @@ fn absolute_layout_in_wrap_reverse_column_container() {
             flex_direction: stretch::style::FlexDirection::Column,
             flex_wrap: stretch::style::FlexWrap::WrapReverse,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(20.0000),
-                    height: stretch::style::Dimension::Points(20.0000),
+                    width: stretch::style::Dimension::Points(20f32),
+                    height: stretch::style::Dimension::Points(20f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -23,14 +23,12 @@ fn absolute_layout_in_wrap_reverse_column_container() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].location.x, 80.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].location.x, 80f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/absolute_layout_in_wrap_reverse_column_container_flex_end.rs b/tests/generated/absolute_layout_in_wrap_reverse_column_container_flex_end.rs
index 2c6dd49f6..c70e403a8 100644
--- a/tests/generated/absolute_layout_in_wrap_reverse_column_container_flex_end.rs
+++ b/tests/generated/absolute_layout_in_wrap_reverse_column_container_flex_end.rs
@@ -5,16 +5,16 @@ fn absolute_layout_in_wrap_reverse_column_container_flex_end() {
             flex_direction: stretch::style::FlexDirection::Column,
             flex_wrap: stretch::style::FlexWrap::WrapReverse,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 align_self: stretch::style::AlignSelf::FlexEnd,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(20.0000),
-                    height: stretch::style::Dimension::Points(20.0000),
+                    width: stretch::style::Dimension::Points(20f32),
+                    height: stretch::style::Dimension::Points(20f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -24,14 +24,12 @@ fn absolute_layout_in_wrap_reverse_column_container_flex_end() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/absolute_layout_in_wrap_reverse_row_container.rs b/tests/generated/absolute_layout_in_wrap_reverse_row_container.rs
index d283e14d6..6a9ee0db1 100644
--- a/tests/generated/absolute_layout_in_wrap_reverse_row_container.rs
+++ b/tests/generated/absolute_layout_in_wrap_reverse_row_container.rs
@@ -4,15 +4,15 @@ fn absolute_layout_in_wrap_reverse_row_container() {
         &stretch::style::Node {
             flex_wrap: stretch::style::FlexWrap::WrapReverse,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(20.0000),
-                    height: stretch::style::Dimension::Points(20.0000),
+                    width: stretch::style::Dimension::Points(20f32),
+                    height: stretch::style::Dimension::Points(20f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -22,14 +22,12 @@ fn absolute_layout_in_wrap_reverse_row_container() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 80.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 80f32);
 }
diff --git a/tests/generated/absolute_layout_in_wrap_reverse_row_container_flex_end.rs b/tests/generated/absolute_layout_in_wrap_reverse_row_container_flex_end.rs
index e894511cc..c05c6e9de 100644
--- a/tests/generated/absolute_layout_in_wrap_reverse_row_container_flex_end.rs
+++ b/tests/generated/absolute_layout_in_wrap_reverse_row_container_flex_end.rs
@@ -4,16 +4,16 @@ fn absolute_layout_in_wrap_reverse_row_container_flex_end() {
         &stretch::style::Node {
             flex_wrap: stretch::style::FlexWrap::WrapReverse,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 align_self: stretch::style::AlignSelf::FlexEnd,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(20.0000),
-                    height: stretch::style::Dimension::Points(20.0000),
+                    width: stretch::style::Dimension::Points(20f32),
+                    height: stretch::style::Dimension::Points(20f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -23,14 +23,12 @@ fn absolute_layout_in_wrap_reverse_row_container_flex_end() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/absolute_layout_justify_content_center.rs b/tests/generated/absolute_layout_justify_content_center.rs
index 0c7f16183..9d5976d40 100644
--- a/tests/generated/absolute_layout_justify_content_center.rs
+++ b/tests/generated/absolute_layout_justify_content_center.rs
@@ -4,15 +4,15 @@ fn absolute_layout_justify_content_center() {
         &stretch::style::Node {
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(110.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(110f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(60.0000),
-                    height: stretch::style::Dimension::Points(40.0000),
+                    width: stretch::style::Dimension::Points(60f32),
+                    height: stretch::style::Dimension::Points(40f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -22,14 +22,12 @@ fn absolute_layout_justify_content_center() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 110.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 40.0000);
-    assert_eq!(layout.children[0].location.x, 25.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 110f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 40f32);
+    assert_eq!(layout.children[0usize].location.x, 25f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/absolute_layout_no_size.rs b/tests/generated/absolute_layout_no_size.rs
index 459e3b165..f01cbac6a 100644
--- a/tests/generated/absolute_layout_no_size.rs
+++ b/tests/generated/absolute_layout_no_size.rs
@@ -3,8 +3,8 @@ fn absolute_layout_no_size() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
@@ -16,14 +16,12 @@ fn absolute_layout_no_size() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 0.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 0f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/absolute_layout_percentage_bottom_based_on_parent_height.rs b/tests/generated/absolute_layout_percentage_bottom_based_on_parent_height.rs
index fd77e36b9..41f001088 100644
--- a/tests/generated/absolute_layout_percentage_bottom_based_on_parent_height.rs
+++ b/tests/generated/absolute_layout_percentage_bottom_based_on_parent_height.rs
@@ -3,20 +3,20 @@ fn absolute_layout_percentage_bottom_based_on_parent_height() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(200.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(200f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     position_type: stretch::style::PositionType::Absolute,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
-                        height: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     position: stretch::geometry::Rect {
-                        top: stretch::style::Dimension::Percent(0.5000),
+                        top: stretch::style::Dimension::Percent(0.5f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -24,12 +24,12 @@ fn absolute_layout_percentage_bottom_based_on_parent_height() {
                 stretch::style::Node {
                     position_type: stretch::style::PositionType::Absolute,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
-                        height: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     position: stretch::geometry::Rect {
-                        bottom: stretch::style::Dimension::Percent(0.5000),
+                        bottom: stretch::style::Dimension::Percent(0.5f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -37,12 +37,12 @@ fn absolute_layout_percentage_bottom_based_on_parent_height() {
                 stretch::style::Node {
                     position_type: stretch::style::PositionType::Absolute,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     position: stretch::geometry::Rect {
-                        top: stretch::style::Dimension::Percent(0.1000),
-                        bottom: stretch::style::Dimension::Percent(0.1000),
+                        top: stretch::style::Dimension::Percent(0.1f32),
+                        bottom: stretch::style::Dimension::Percent(0.1f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -53,24 +53,20 @@ fn absolute_layout_percentage_bottom_based_on_parent_height() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 200.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 100.0000);
-
-    assert_eq!(layout.children[1].size.width, 10.0000);
-    assert_eq!(layout.children[1].size.height, 10.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 90.0000);
-
-    assert_eq!(layout.children[2].size.width, 10.0000);
-    assert_eq!(layout.children[2].size.height, 160.0000);
-    assert_eq!(layout.children[2].location.x, 0.0000);
-    assert_eq!(layout.children[2].location.y, 20.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 200f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 100f32);
+    assert_eq!(layout.children[1usize].size.width, 10f32);
+    assert_eq!(layout.children[1usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 90f32);
+    assert_eq!(layout.children[2usize].size.width, 10f32);
+    assert_eq!(layout.children[2usize].size.height, 160f32);
+    assert_eq!(layout.children[2usize].location.x, 0f32);
+    assert_eq!(layout.children[2usize].location.y, 20f32);
 }
diff --git a/tests/generated/absolute_layout_start_top_end_bottom.rs b/tests/generated/absolute_layout_start_top_end_bottom.rs
index 114c55fb1..7a22d6876 100644
--- a/tests/generated/absolute_layout_start_top_end_bottom.rs
+++ b/tests/generated/absolute_layout_start_top_end_bottom.rs
@@ -3,17 +3,17 @@ fn absolute_layout_start_top_end_bottom() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 position: stretch::geometry::Rect {
-                    start: stretch::style::Dimension::Points(10.0000),
-                    end: stretch::style::Dimension::Points(10.0000),
-                    top: stretch::style::Dimension::Points(10.0000),
-                    bottom: stretch::style::Dimension::Points(10.0000),
+                    start: stretch::style::Dimension::Points(10f32),
+                    end: stretch::style::Dimension::Points(10f32),
+                    top: stretch::style::Dimension::Points(10f32),
+                    bottom: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -23,14 +23,12 @@ fn absolute_layout_start_top_end_bottom() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 80.0000);
-    assert_eq!(layout.children[0].size.height, 80.0000);
-    assert_eq!(layout.children[0].location.x, 10.0000);
-    assert_eq!(layout.children[0].location.y, 10.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 80f32);
+    assert_eq!(layout.children[0usize].size.height, 80f32);
+    assert_eq!(layout.children[0usize].location.x, 10f32);
+    assert_eq!(layout.children[0usize].location.y, 10f32);
 }
diff --git a/tests/generated/absolute_layout_width_height_end_bottom.rs b/tests/generated/absolute_layout_width_height_end_bottom.rs
index 69936d137..ac06e3638 100644
--- a/tests/generated/absolute_layout_width_height_end_bottom.rs
+++ b/tests/generated/absolute_layout_width_height_end_bottom.rs
@@ -3,20 +3,20 @@ fn absolute_layout_width_height_end_bottom() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 position: stretch::geometry::Rect {
-                    end: stretch::style::Dimension::Points(10.0000),
-                    bottom: stretch::style::Dimension::Points(10.0000),
+                    end: stretch::style::Dimension::Points(10f32),
+                    bottom: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -26,14 +26,12 @@ fn absolute_layout_width_height_end_bottom() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 80.0000);
-    assert_eq!(layout.children[0].location.y, 80.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 80f32);
+    assert_eq!(layout.children[0usize].location.y, 80f32);
 }
diff --git a/tests/generated/absolute_layout_width_height_start_top.rs b/tests/generated/absolute_layout_width_height_start_top.rs
index 184a5aeb7..731e953ec 100644
--- a/tests/generated/absolute_layout_width_height_start_top.rs
+++ b/tests/generated/absolute_layout_width_height_start_top.rs
@@ -3,20 +3,20 @@ fn absolute_layout_width_height_start_top() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 position: stretch::geometry::Rect {
-                    start: stretch::style::Dimension::Points(10.0000),
-                    top: stretch::style::Dimension::Points(10.0000),
+                    start: stretch::style::Dimension::Points(10f32),
+                    top: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -26,14 +26,12 @@ fn absolute_layout_width_height_start_top() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 10.0000);
-    assert_eq!(layout.children[0].location.y, 10.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 10f32);
+    assert_eq!(layout.children[0usize].location.y, 10f32);
 }
diff --git a/tests/generated/absolute_layout_width_height_start_top_end_bottom.rs b/tests/generated/absolute_layout_width_height_start_top_end_bottom.rs
index f3c19ee0d..e3642d466 100644
--- a/tests/generated/absolute_layout_width_height_start_top_end_bottom.rs
+++ b/tests/generated/absolute_layout_width_height_start_top_end_bottom.rs
@@ -3,22 +3,22 @@ fn absolute_layout_width_height_start_top_end_bottom() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 position_type: stretch::style::PositionType::Absolute,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 position: stretch::geometry::Rect {
-                    start: stretch::style::Dimension::Points(10.0000),
-                    end: stretch::style::Dimension::Points(10.0000),
-                    top: stretch::style::Dimension::Points(10.0000),
-                    bottom: stretch::style::Dimension::Points(10.0000),
+                    start: stretch::style::Dimension::Points(10f32),
+                    end: stretch::style::Dimension::Points(10f32),
+                    top: stretch::style::Dimension::Points(10f32),
+                    bottom: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -28,14 +28,12 @@ fn absolute_layout_width_height_start_top_end_bottom() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 10.0000);
-    assert_eq!(layout.children[0].location.y, 10.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 10f32);
+    assert_eq!(layout.children[0usize].location.y, 10f32);
 }
diff --git a/tests/generated/absolute_layout_within_border.rs b/tests/generated/absolute_layout_within_border.rs
index 961ea161a..9627c29b8 100644
--- a/tests/generated/absolute_layout_within_border.rs
+++ b/tests/generated/absolute_layout_within_border.rs
@@ -3,35 +3,21 @@ fn absolute_layout_within_border() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
-                ..Default::default()
-            },
-            padding: stretch::geometry::Rect {
-                start: stretch::style::Dimension::Points(10.0000),
-                end: stretch::style::Dimension::Points(10.0000),
-                top: stretch::style::Dimension::Points(10.0000),
-                bottom: stretch::style::Dimension::Points(10.0000),
-                ..Default::default()
-            },
-            border: stretch::geometry::Rect {
-                start: stretch::style::Dimension::Points(10.0000),
-                end: stretch::style::Dimension::Points(10.0000),
-                top: stretch::style::Dimension::Points(10.0000),
-                bottom: stretch::style::Dimension::Points(10.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     position_type: stretch::style::PositionType::Absolute,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     position: stretch::geometry::Rect {
-                        start: stretch::style::Dimension::Points(0.0000),
-                        top: stretch::style::Dimension::Points(0.0000),
+                        start: stretch::style::Dimension::Points(0f32),
+                        top: stretch::style::Dimension::Points(0f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -39,13 +25,13 @@ fn absolute_layout_within_border() {
                 stretch::style::Node {
                     position_type: stretch::style::PositionType::Absolute,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     position: stretch::geometry::Rect {
-                        end: stretch::style::Dimension::Points(0.0000),
-                        bottom: stretch::style::Dimension::Points(0.0000),
+                        end: stretch::style::Dimension::Points(0f32),
+                        bottom: stretch::style::Dimension::Points(0f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -53,20 +39,20 @@ fn absolute_layout_within_border() {
                 stretch::style::Node {
                     position_type: stretch::style::PositionType::Absolute,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     margin: stretch::geometry::Rect {
-                        start: stretch::style::Dimension::Points(10.0000),
-                        end: stretch::style::Dimension::Points(10.0000),
-                        top: stretch::style::Dimension::Points(10.0000),
-                        bottom: stretch::style::Dimension::Points(10.0000),
+                        start: stretch::style::Dimension::Points(10f32),
+                        end: stretch::style::Dimension::Points(10f32),
+                        top: stretch::style::Dimension::Points(10f32),
+                        bottom: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     position: stretch::geometry::Rect {
-                        start: stretch::style::Dimension::Points(0.0000),
-                        top: stretch::style::Dimension::Points(0.0000),
+                        start: stretch::style::Dimension::Points(0f32),
+                        top: stretch::style::Dimension::Points(0f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -74,53 +60,62 @@ fn absolute_layout_within_border() {
                 stretch::style::Node {
                     position_type: stretch::style::PositionType::Absolute,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     margin: stretch::geometry::Rect {
-                        start: stretch::style::Dimension::Points(10.0000),
-                        end: stretch::style::Dimension::Points(10.0000),
-                        top: stretch::style::Dimension::Points(10.0000),
-                        bottom: stretch::style::Dimension::Points(10.0000),
+                        start: stretch::style::Dimension::Points(10f32),
+                        end: stretch::style::Dimension::Points(10f32),
+                        top: stretch::style::Dimension::Points(10f32),
+                        bottom: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     position: stretch::geometry::Rect {
-                        end: stretch::style::Dimension::Points(0.0000),
-                        bottom: stretch::style::Dimension::Points(0.0000),
+                        end: stretch::style::Dimension::Points(0f32),
+                        bottom: stretch::style::Dimension::Points(0f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
             ],
+            padding: stretch::geometry::Rect {
+                start: stretch::style::Dimension::Points(10f32),
+                end: stretch::style::Dimension::Points(10f32),
+                top: stretch::style::Dimension::Points(10f32),
+                bottom: stretch::style::Dimension::Points(10f32),
+                ..Default::default()
+            },
+            border: stretch::geometry::Rect {
+                start: stretch::style::Dimension::Points(10f32),
+                end: stretch::style::Dimension::Points(10f32),
+                top: stretch::style::Dimension::Points(10f32),
+                bottom: stretch::style::Dimension::Points(10f32),
+                ..Default::default()
+            },
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 10.0000);
-    assert_eq!(layout.children[0].location.y, 10.0000);
-
-    assert_eq!(layout.children[1].size.width, 50.0000);
-    assert_eq!(layout.children[1].size.height, 50.0000);
-    assert_eq!(layout.children[1].location.x, 40.0000);
-    assert_eq!(layout.children[1].location.y, 40.0000);
-
-    assert_eq!(layout.children[2].size.width, 50.0000);
-    assert_eq!(layout.children[2].size.height, 50.0000);
-    assert_eq!(layout.children[2].location.x, 20.0000);
-    assert_eq!(layout.children[2].location.y, 20.0000);
-
-    assert_eq!(layout.children[3].size.width, 50.0000);
-    assert_eq!(layout.children[3].size.height, 50.0000);
-    assert_eq!(layout.children[3].location.x, 30.0000);
-    assert_eq!(layout.children[3].location.y, 30.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 10f32);
+    assert_eq!(layout.children[0usize].location.y, 10f32);
+    assert_eq!(layout.children[1usize].size.width, 50f32);
+    assert_eq!(layout.children[1usize].size.height, 50f32);
+    assert_eq!(layout.children[1usize].location.x, 40f32);
+    assert_eq!(layout.children[1usize].location.y, 40f32);
+    assert_eq!(layout.children[2usize].size.width, 50f32);
+    assert_eq!(layout.children[2usize].size.height, 50f32);
+    assert_eq!(layout.children[2usize].location.x, 20f32);
+    assert_eq!(layout.children[2usize].location.y, 20f32);
+    assert_eq!(layout.children[3usize].size.width, 50f32);
+    assert_eq!(layout.children[3usize].size.height, 50f32);
+    assert_eq!(layout.children[3usize].location.x, 30f32);
+    assert_eq!(layout.children[3usize].location.y, 30f32);
 }
diff --git a/tests/generated/align_baseline.rs b/tests/generated/align_baseline.rs
index 8dc49f672..1cce90b63 100644
--- a/tests/generated/align_baseline.rs
+++ b/tests/generated/align_baseline.rs
@@ -4,23 +4,23 @@ fn align_baseline() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::Baseline,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(20.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -31,19 +31,16 @@ fn align_baseline() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 50.0000);
-    assert_eq!(layout.children[1].size.height, 20.0000);
-    assert_eq!(layout.children[1].location.x, 50.0000);
-    assert_eq!(layout.children[1].location.y, 30.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 50f32);
+    assert_eq!(layout.children[1usize].size.height, 20f32);
+    assert_eq!(layout.children[1usize].location.x, 50f32);
+    assert_eq!(layout.children[1usize].location.y, 30f32);
 }
diff --git a/tests/generated/align_baseline_child_multiline.rs b/tests/generated/align_baseline_child_multiline.rs
index 1128aa5a9..753ae804a 100644
--- a/tests/generated/align_baseline_child_multiline.rs
+++ b/tests/generated/align_baseline_child_multiline.rs
@@ -3,12 +3,12 @@ fn align_baseline_child_multiline() {
     let layout = stretch::compute(
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::Baseline,
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(60.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(60f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -16,38 +16,38 @@ fn align_baseline_child_multiline() {
                 stretch::style::Node {
                     flex_wrap: stretch::style::FlexWrap::Wrap,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     children: vec![
                         stretch::style::Node {
                             size: stretch::geometry::Size {
-                                width: stretch::style::Dimension::Points(25.0000),
-                                height: stretch::style::Dimension::Points(20.0000),
+                                width: stretch::style::Dimension::Points(25f32),
+                                height: stretch::style::Dimension::Points(20f32),
                                 ..Default::default()
                             },
                             ..Default::default()
                         },
                         stretch::style::Node {
                             size: stretch::geometry::Size {
-                                width: stretch::style::Dimension::Points(25.0000),
-                                height: stretch::style::Dimension::Points(10.0000),
+                                width: stretch::style::Dimension::Points(25f32),
+                                height: stretch::style::Dimension::Points(10f32),
                                 ..Default::default()
                             },
                             ..Default::default()
                         },
                         stretch::style::Node {
                             size: stretch::geometry::Size {
-                                width: stretch::style::Dimension::Points(25.0000),
-                                height: stretch::style::Dimension::Points(20.0000),
+                                width: stretch::style::Dimension::Points(25f32),
+                                height: stretch::style::Dimension::Points(20f32),
                                 ..Default::default()
                             },
                             ..Default::default()
                         },
                         stretch::style::Node {
                             size: stretch::geometry::Size {
-                                width: stretch::style::Dimension::Points(25.0000),
-                                height: stretch::style::Dimension::Points(10.0000),
+                                width: stretch::style::Dimension::Points(25f32),
+                                height: stretch::style::Dimension::Points(10f32),
                                 ..Default::default()
                             },
                             ..Default::default()
@@ -61,39 +61,32 @@ fn align_baseline_child_multiline() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 80.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 60.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 50.0000);
-    assert_eq!(layout.children[1].size.height, 40.0000);
-    assert_eq!(layout.children[1].location.x, 50.0000);
-    assert_eq!(layout.children[1].location.y, 40.0000);
-
-    assert_eq!(layout.children[1].children[0].size.width, 25.0000);
-    assert_eq!(layout.children[1].children[0].size.height, 20.0000);
-    assert_eq!(layout.children[1].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[1].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].children[1].size.width, 25.0000);
-    assert_eq!(layout.children[1].children[1].size.height, 10.0000);
-    assert_eq!(layout.children[1].children[1].location.x, 25.0000);
-    assert_eq!(layout.children[1].children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].children[2].size.width, 25.0000);
-    assert_eq!(layout.children[1].children[2].size.height, 20.0000);
-    assert_eq!(layout.children[1].children[2].location.x, 0.0000);
-    assert_eq!(layout.children[1].children[2].location.y, 20.0000);
-
-    assert_eq!(layout.children[1].children[3].size.width, 25.0000);
-    assert_eq!(layout.children[1].children[3].size.height, 10.0000);
-    assert_eq!(layout.children[1].children[3].location.x, 25.0000);
-    assert_eq!(layout.children[1].children[3].location.y, 20.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 80f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 60f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 50f32);
+    assert_eq!(layout.children[1usize].size.height, 40f32);
+    assert_eq!(layout.children[1usize].location.x, 50f32);
+    assert_eq!(layout.children[1usize].location.y, 40f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.width, 25f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].children[1usize].size.width, 25f32);
+    assert_eq!(layout.children[1usize].children[1usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].children[1usize].location.x, 25f32);
+    assert_eq!(layout.children[1usize].children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].children[2usize].size.width, 25f32);
+    assert_eq!(layout.children[1usize].children[2usize].size.height, 20f32);
+    assert_eq!(layout.children[1usize].children[2usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].children[2usize].location.y, 20f32);
+    assert_eq!(layout.children[1usize].children[3usize].size.width, 25f32);
+    assert_eq!(layout.children[1usize].children[3usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].children[3usize].location.x, 25f32);
+    assert_eq!(layout.children[1usize].children[3usize].location.y, 20f32);
 }
diff --git a/tests/generated/align_baseline_nested_child.rs b/tests/generated/align_baseline_nested_child.rs
index 29409309d..565dd05cd 100644
--- a/tests/generated/align_baseline_nested_child.rs
+++ b/tests/generated/align_baseline_nested_child.rs
@@ -4,15 +4,15 @@ fn align_baseline_nested_child() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::Baseline,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -20,14 +20,14 @@ fn align_baseline_nested_child() {
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(20.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(50.0000),
-                            height: stretch::style::Dimension::Points(10.0000),
+                            width: stretch::style::Dimension::Points(50f32),
+                            height: stretch::style::Dimension::Points(10f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -40,24 +40,20 @@ fn align_baseline_nested_child() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 50.0000);
-    assert_eq!(layout.children[1].size.height, 20.0000);
-    assert_eq!(layout.children[1].location.x, 50.0000);
-    assert_eq!(layout.children[1].location.y, 40.0000);
-
-    assert_eq!(layout.children[1].children[0].size.width, 50.0000);
-    assert_eq!(layout.children[1].children[0].size.height, 10.0000);
-    assert_eq!(layout.children[1].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[1].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 50f32);
+    assert_eq!(layout.children[1usize].size.height, 20f32);
+    assert_eq!(layout.children[1usize].location.x, 50f32);
+    assert_eq!(layout.children[1usize].location.y, 40f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_center_should_size_based_on_content.rs b/tests/generated/align_center_should_size_based_on_content.rs
index 003c2f362..586225077 100644
--- a/tests/generated/align_center_should_size_based_on_content.rs
+++ b/tests/generated/align_center_should_size_based_on_content.rs
@@ -4,21 +4,21 @@ fn align_center_should_size_based_on_content() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 justify_content: stretch::style::JustifyContent::Center,
-                flex_grow: 0.0000,
-                flex_shrink: 1.0000,
+                flex_grow: 0f32,
+                flex_shrink: 1f32,
                 children: vec![stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 1.0000,
+                    flex_grow: 1f32,
+                    flex_shrink: 1f32,
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(20.0000),
-                            height: stretch::style::Dimension::Points(20.0000),
+                            width: stretch::style::Dimension::Points(20f32),
+                            height: stretch::style::Dimension::Points(20f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -32,24 +32,20 @@ fn align_center_should_size_based_on_content() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 40.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].children[0].children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 40f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_flex_start_with_shrinking_children.rs b/tests/generated/align_flex_start_with_shrinking_children.rs
index f92de9608..c94a24af5 100644
--- a/tests/generated/align_flex_start_with_shrinking_children.rs
+++ b/tests/generated/align_flex_start_with_shrinking_children.rs
@@ -3,20 +3,16 @@ fn align_flex_start_with_shrinking_children() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(500.0000),
-                height: stretch::style::Dimension::Points(500.0000),
+                width: stretch::style::Dimension::Points(500f32),
+                height: stretch::style::Dimension::Points(500f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 align_items: stretch::style::AlignItems::FlexStart,
                 children: vec![stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 1.0000,
-                    children: vec![stretch::style::Node {
-                        flex_grow: 1.0000,
-                        flex_shrink: 1.0000,
-                        ..Default::default()
-                    }],
+                    flex_grow: 1f32,
+                    flex_shrink: 1f32,
+                    children: vec![stretch::style::Node { flex_grow: 1f32, flex_shrink: 1f32, ..Default::default() }],
                     ..Default::default()
                 }],
                 ..Default::default()
@@ -26,24 +22,20 @@ fn align_flex_start_with_shrinking_children() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 500.0000);
-    assert_eq!(layout.size.height, 500.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 500.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].size.height, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 500f32);
+    assert_eq!(layout.size.height, 500f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 500f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.height, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_flex_start_with_shrinking_children_with_stretch.rs b/tests/generated/align_flex_start_with_shrinking_children_with_stretch.rs
index 993224c1c..a45757353 100644
--- a/tests/generated/align_flex_start_with_shrinking_children_with_stretch.rs
+++ b/tests/generated/align_flex_start_with_shrinking_children_with_stretch.rs
@@ -3,20 +3,16 @@ fn align_flex_start_with_shrinking_children_with_stretch() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(500.0000),
-                height: stretch::style::Dimension::Points(500.0000),
+                width: stretch::style::Dimension::Points(500f32),
+                height: stretch::style::Dimension::Points(500f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 align_items: stretch::style::AlignItems::FlexStart,
                 children: vec![stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 1.0000,
-                    children: vec![stretch::style::Node {
-                        flex_grow: 1.0000,
-                        flex_shrink: 1.0000,
-                        ..Default::default()
-                    }],
+                    flex_grow: 1f32,
+                    flex_shrink: 1f32,
+                    children: vec![stretch::style::Node { flex_grow: 1f32, flex_shrink: 1f32, ..Default::default() }],
                     ..Default::default()
                 }],
                 ..Default::default()
@@ -26,24 +22,20 @@ fn align_flex_start_with_shrinking_children_with_stretch() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 500.0000);
-    assert_eq!(layout.size.height, 500.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 500.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].size.height, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 500f32);
+    assert_eq!(layout.size.height, 500f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 500f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.height, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_flex_start_with_stretching_children.rs b/tests/generated/align_flex_start_with_stretching_children.rs
index a1be38bf2..16c8acc7b 100644
--- a/tests/generated/align_flex_start_with_stretching_children.rs
+++ b/tests/generated/align_flex_start_with_stretching_children.rs
@@ -3,19 +3,15 @@ fn align_flex_start_with_stretching_children() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(500.0000),
-                height: stretch::style::Dimension::Points(500.0000),
+                width: stretch::style::Dimension::Points(500f32),
+                height: stretch::style::Dimension::Points(500f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 children: vec![stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 1.0000,
-                    children: vec![stretch::style::Node {
-                        flex_grow: 1.0000,
-                        flex_shrink: 1.0000,
-                        ..Default::default()
-                    }],
+                    flex_grow: 1f32,
+                    flex_shrink: 1f32,
+                    children: vec![stretch::style::Node { flex_grow: 1f32, flex_shrink: 1f32, ..Default::default() }],
                     ..Default::default()
                 }],
                 ..Default::default()
@@ -25,24 +21,20 @@ fn align_flex_start_with_stretching_children() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 500.0000);
-    assert_eq!(layout.size.height, 500.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 500.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 500.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].size.height, 500.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 500f32);
+    assert_eq!(layout.size.height, 500f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 500f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 500f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.height, 500f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_items_center.rs b/tests/generated/align_items_center.rs
index 8aa146932..5c6eee058 100644
--- a/tests/generated/align_items_center.rs
+++ b/tests/generated/align_items_center.rs
@@ -4,14 +4,14 @@ fn align_items_center() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -21,14 +21,12 @@ fn align_items_center() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 45.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 45f32);
 }
diff --git a/tests/generated/align_items_center_child_with_margin_bigger_than_parent.rs b/tests/generated/align_items_center_child_with_margin_bigger_than_parent.rs
index 666d43b91..dc8023af0 100644
--- a/tests/generated/align_items_center_child_with_margin_bigger_than_parent.rs
+++ b/tests/generated/align_items_center_child_with_margin_bigger_than_parent.rs
@@ -5,21 +5,21 @@ fn align_items_center_child_with_margin_bigger_than_parent() {
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(50.0000),
-                height: stretch::style::Dimension::Points(50.0000),
+                width: stretch::style::Dimension::Points(50f32),
+                height: stretch::style::Dimension::Points(50f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 align_items: stretch::style::AlignItems::Center,
                 children: vec![stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     margin: stretch::geometry::Rect {
-                        start: stretch::style::Dimension::Points(10.0000),
-                        end: stretch::style::Dimension::Points(10.0000),
+                        start: stretch::style::Dimension::Points(10f32),
+                        end: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -31,19 +31,16 @@ fn align_items_center_child_with_margin_bigger_than_parent() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 50.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, -10.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 10.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 50f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, -10f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 10f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_items_center_child_without_margin_bigger_than_parent.rs b/tests/generated/align_items_center_child_without_margin_bigger_than_parent.rs
index a0376b760..35d18b138 100644
--- a/tests/generated/align_items_center_child_without_margin_bigger_than_parent.rs
+++ b/tests/generated/align_items_center_child_without_margin_bigger_than_parent.rs
@@ -5,16 +5,16 @@ fn align_items_center_child_without_margin_bigger_than_parent() {
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(50.0000),
-                height: stretch::style::Dimension::Points(50.0000),
+                width: stretch::style::Dimension::Points(50f32),
+                height: stretch::style::Dimension::Points(50f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 align_items: stretch::style::AlignItems::Center,
                 children: vec![stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(70.0000),
-                        height: stretch::style::Dimension::Points(70.0000),
+                        width: stretch::style::Dimension::Points(70f32),
+                        height: stretch::style::Dimension::Points(70f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -26,19 +26,16 @@ fn align_items_center_child_without_margin_bigger_than_parent() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 50.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].size.height, 70.0000);
-    assert_eq!(layout.children[0].location.x, -10.0000);
-    assert_eq!(layout.children[0].location.y, -10.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 70.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 50f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].size.height, 70f32);
+    assert_eq!(layout.children[0usize].location.x, -10f32);
+    assert_eq!(layout.children[0usize].location.y, -10f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 70f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_items_center_with_child_margin.rs b/tests/generated/align_items_center_with_child_margin.rs
index 61ad29371..686190702 100644
--- a/tests/generated/align_items_center_with_child_margin.rs
+++ b/tests/generated/align_items_center_with_child_margin.rs
@@ -4,20 +4,17 @@ fn align_items_center_with_child_margin() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
-                    ..Default::default()
-                },
-                margin: stretch::geometry::Rect {
-                    top: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
+                margin: stretch::geometry::Rect { top: stretch::style::Dimension::Points(10f32), ..Default::default() },
                 ..Default::default()
             }],
             ..Default::default()
@@ -25,14 +22,12 @@ fn align_items_center_with_child_margin() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 50.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 50f32);
 }
diff --git a/tests/generated/align_items_center_with_child_top.rs b/tests/generated/align_items_center_with_child_top.rs
index 70dcb8c77..f06922e0e 100644
--- a/tests/generated/align_items_center_with_child_top.rs
+++ b/tests/generated/align_items_center_with_child_top.rs
@@ -4,18 +4,18 @@ fn align_items_center_with_child_top() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 position: stretch::geometry::Rect {
-                    top: stretch::style::Dimension::Points(10.0000),
+                    top: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -25,14 +25,12 @@ fn align_items_center_with_child_top() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 55.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 55f32);
 }
diff --git a/tests/generated/align_items_flex_end.rs b/tests/generated/align_items_flex_end.rs
index 967da7a26..de29ede1a 100644
--- a/tests/generated/align_items_flex_end.rs
+++ b/tests/generated/align_items_flex_end.rs
@@ -4,14 +4,14 @@ fn align_items_flex_end() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::FlexEnd,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -21,14 +21,12 @@ fn align_items_flex_end() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 90.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 90f32);
 }
diff --git a/tests/generated/align_items_flex_end_child_with_margin_bigger_than_parent.rs b/tests/generated/align_items_flex_end_child_with_margin_bigger_than_parent.rs
index 573fe1f01..01ef89c0c 100644
--- a/tests/generated/align_items_flex_end_child_with_margin_bigger_than_parent.rs
+++ b/tests/generated/align_items_flex_end_child_with_margin_bigger_than_parent.rs
@@ -5,21 +5,21 @@ fn align_items_flex_end_child_with_margin_bigger_than_parent() {
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(50.0000),
-                height: stretch::style::Dimension::Points(50.0000),
+                width: stretch::style::Dimension::Points(50f32),
+                height: stretch::style::Dimension::Points(50f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 align_items: stretch::style::AlignItems::FlexEnd,
                 children: vec![stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     margin: stretch::geometry::Rect {
-                        start: stretch::style::Dimension::Points(10.0000),
-                        end: stretch::style::Dimension::Points(10.0000),
+                        start: stretch::style::Dimension::Points(10f32),
+                        end: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -31,19 +31,16 @@ fn align_items_flex_end_child_with_margin_bigger_than_parent() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 50.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, -10.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 10.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 50f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, -10f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 10f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_items_flex_end_child_without_margin_bigger_than_parent.rs b/tests/generated/align_items_flex_end_child_without_margin_bigger_than_parent.rs
index 6a0d598e9..8e8c1763b 100644
--- a/tests/generated/align_items_flex_end_child_without_margin_bigger_than_parent.rs
+++ b/tests/generated/align_items_flex_end_child_without_margin_bigger_than_parent.rs
@@ -5,16 +5,16 @@ fn align_items_flex_end_child_without_margin_bigger_than_parent() {
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(50.0000),
-                height: stretch::style::Dimension::Points(50.0000),
+                width: stretch::style::Dimension::Points(50f32),
+                height: stretch::style::Dimension::Points(50f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 align_items: stretch::style::AlignItems::FlexEnd,
                 children: vec![stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(70.0000),
-                        height: stretch::style::Dimension::Points(70.0000),
+                        width: stretch::style::Dimension::Points(70f32),
+                        height: stretch::style::Dimension::Points(70f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -26,19 +26,16 @@ fn align_items_flex_end_child_without_margin_bigger_than_parent() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 50.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].size.height, 70.0000);
-    assert_eq!(layout.children[0].location.x, -10.0000);
-    assert_eq!(layout.children[0].location.y, -10.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 70.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 50f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].size.height, 70f32);
+    assert_eq!(layout.children[0usize].location.x, -10f32);
+    assert_eq!(layout.children[0usize].location.y, -10f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 70f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_items_flex_start.rs b/tests/generated/align_items_flex_start.rs
index 68ebcb96e..3ca8015c1 100644
--- a/tests/generated/align_items_flex_start.rs
+++ b/tests/generated/align_items_flex_start.rs
@@ -4,14 +4,14 @@ fn align_items_flex_start() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::FlexStart,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -21,14 +21,12 @@ fn align_items_flex_start() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_items_min_max.rs b/tests/generated/align_items_min_max.rs
index 2dbf43aea..143636859 100644
--- a/tests/generated/align_items_min_max.rs
+++ b/tests/generated/align_items_min_max.rs
@@ -4,19 +4,19 @@ fn align_items_min_max() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
             align_items: stretch::style::AlignItems::Center,
-            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100f32), ..Default::default() },
             min_size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             max_size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(200.0000),
+                width: stretch::style::Dimension::Points(200f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(60.0000),
-                    height: stretch::style::Dimension::Points(60.0000),
+                    width: stretch::style::Dimension::Points(60f32),
+                    height: stretch::style::Dimension::Points(60f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -26,14 +26,12 @@ fn align_items_min_max() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 60.0000);
-    assert_eq!(layout.children[0].location.x, 20.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 60f32);
+    assert_eq!(layout.children[0usize].location.x, 20f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_items_stretch.rs b/tests/generated/align_items_stretch.rs
index 08eb94e63..8269ef1ee 100644
--- a/tests/generated/align_items_stretch.rs
+++ b/tests/generated/align_items_stretch.rs
@@ -3,15 +3,12 @@ fn align_items_stretch() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
-                size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    ..Default::default()
-                },
+                size: stretch::geometry::Size { width: stretch::style::Dimension::Points(10f32), ..Default::default() },
                 ..Default::default()
             }],
             ..Default::default()
@@ -19,14 +16,12 @@ fn align_items_stretch() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_self_baseline.rs b/tests/generated/align_self_baseline.rs
index 5bb4ef4c4..83a9025d4 100644
--- a/tests/generated/align_self_baseline.rs
+++ b/tests/generated/align_self_baseline.rs
@@ -3,16 +3,16 @@ fn align_self_baseline() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     align_self: stretch::style::AlignSelf::Baseline,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -20,14 +20,14 @@ fn align_self_baseline() {
                 stretch::style::Node {
                     align_self: stretch::style::AlignSelf::Baseline,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(20.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(50.0000),
-                            height: stretch::style::Dimension::Points(10.0000),
+                            width: stretch::style::Dimension::Points(50f32),
+                            height: stretch::style::Dimension::Points(10f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -40,24 +40,20 @@ fn align_self_baseline() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 50.0000);
-    assert_eq!(layout.children[1].size.height, 20.0000);
-    assert_eq!(layout.children[1].location.x, 50.0000);
-    assert_eq!(layout.children[1].location.y, 40.0000);
-
-    assert_eq!(layout.children[1].children[0].size.width, 50.0000);
-    assert_eq!(layout.children[1].children[0].size.height, 10.0000);
-    assert_eq!(layout.children[1].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[1].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 50f32);
+    assert_eq!(layout.children[1usize].size.height, 20f32);
+    assert_eq!(layout.children[1usize].location.x, 50f32);
+    assert_eq!(layout.children[1usize].location.y, 40f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_self_center.rs b/tests/generated/align_self_center.rs
index b2f7c6697..a5e564fdf 100644
--- a/tests/generated/align_self_center.rs
+++ b/tests/generated/align_self_center.rs
@@ -3,15 +3,15 @@ fn align_self_center() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 align_self: stretch::style::AlignSelf::Center,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -21,14 +21,12 @@ fn align_self_center() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 45.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 45f32);
 }
diff --git a/tests/generated/align_self_flex_end.rs b/tests/generated/align_self_flex_end.rs
index 52c8c6fab..343bf0594 100644
--- a/tests/generated/align_self_flex_end.rs
+++ b/tests/generated/align_self_flex_end.rs
@@ -3,15 +3,15 @@ fn align_self_flex_end() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 align_self: stretch::style::AlignSelf::FlexEnd,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -21,14 +21,12 @@ fn align_self_flex_end() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 90.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 90f32);
 }
diff --git a/tests/generated/align_self_flex_end_override_flex_start.rs b/tests/generated/align_self_flex_end_override_flex_start.rs
index aaa95191c..ace563ea1 100644
--- a/tests/generated/align_self_flex_end_override_flex_start.rs
+++ b/tests/generated/align_self_flex_end_override_flex_start.rs
@@ -4,15 +4,15 @@ fn align_self_flex_end_override_flex_start() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::FlexStart,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 align_self: stretch::style::AlignSelf::FlexEnd,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -22,14 +22,12 @@ fn align_self_flex_end_override_flex_start() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 90.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 90f32);
 }
diff --git a/tests/generated/align_self_flex_start.rs b/tests/generated/align_self_flex_start.rs
index 8f1f27123..a460ef530 100644
--- a/tests/generated/align_self_flex_start.rs
+++ b/tests/generated/align_self_flex_start.rs
@@ -3,15 +3,15 @@ fn align_self_flex_start() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 align_self: stretch::style::AlignSelf::FlexStart,
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -21,14 +21,12 @@ fn align_self_flex_start() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/align_strech_should_size_based_on_parent.rs b/tests/generated/align_strech_should_size_based_on_parent.rs
index c7ca5e1d3..1dd50de89 100644
--- a/tests/generated/align_strech_should_size_based_on_parent.rs
+++ b/tests/generated/align_strech_should_size_based_on_parent.rs
@@ -3,21 +3,21 @@ fn align_strech_should_size_based_on_parent() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 justify_content: stretch::style::JustifyContent::Center,
-                flex_grow: 0.0000,
-                flex_shrink: 1.0000,
+                flex_grow: 0f32,
+                flex_shrink: 1f32,
                 children: vec![stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 1.0000,
+                    flex_grow: 1f32,
+                    flex_shrink: 1f32,
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(20.0000),
-                            height: stretch::style::Dimension::Points(20.0000),
+                            width: stretch::style::Dimension::Points(20f32),
+                            height: stretch::style::Dimension::Points(20f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -31,24 +31,20 @@ fn align_strech_should_size_based_on_parent() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].children[0].children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/border_center_child.rs b/tests/generated/border_center_child.rs
index d073ecfa9..4da5d3f44 100644
--- a/tests/generated/border_center_child.rs
+++ b/tests/generated/border_center_child.rs
@@ -5,36 +5,34 @@ fn border_center_child() {
             align_items: stretch::style::AlignItems::Center,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
-                ..Default::default()
-            },
-            border: stretch::geometry::Rect {
-                top: stretch::style::Dimension::Points(10.0000),
-                bottom: stretch::style::Dimension::Points(20.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    height: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(10f32),
+                    height: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
             }],
+            border: stretch::geometry::Rect {
+                top: stretch::style::Dimension::Points(10f32),
+                bottom: stretch::style::Dimension::Points(20f32),
+                ..Default::default()
+            },
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 45.0000);
-    assert_eq!(layout.children[0].location.y, 40.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 45f32);
+    assert_eq!(layout.children[0usize].location.y, 40f32);
 }
diff --git a/tests/generated/border_flex_child.rs b/tests/generated/border_flex_child.rs
index 52df14821..80c9dbbd9 100644
--- a/tests/generated/border_flex_child.rs
+++ b/tests/generated/border_flex_child.rs
@@ -3,38 +3,33 @@ fn border_flex_child() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
-                ..Default::default()
-            },
-            border: stretch::geometry::Rect {
-                start: stretch::style::Dimension::Points(10.0000),
-                end: stretch::style::Dimension::Points(10.0000),
-                top: stretch::style::Dimension::Points(10.0000),
-                bottom: stretch::style::Dimension::Points(10.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
-                flex_grow: 1.0000,
-                size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    ..Default::default()
-                },
+                flex_grow: 1f32,
+                size: stretch::geometry::Size { width: stretch::style::Dimension::Points(10f32), ..Default::default() },
                 ..Default::default()
             }],
+            border: stretch::geometry::Rect {
+                start: stretch::style::Dimension::Points(10f32),
+                end: stretch::style::Dimension::Points(10f32),
+                top: stretch::style::Dimension::Points(10f32),
+                bottom: stretch::style::Dimension::Points(10f32),
+                ..Default::default()
+            },
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 80.0000);
-    assert_eq!(layout.children[0].size.height, 80.0000);
-    assert_eq!(layout.children[0].location.x, 10.0000);
-    assert_eq!(layout.children[0].location.y, 10.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 80f32);
+    assert_eq!(layout.children[0usize].size.height, 80f32);
+    assert_eq!(layout.children[0usize].location.x, 10f32);
+    assert_eq!(layout.children[0usize].location.y, 10f32);
 }
diff --git a/tests/generated/border_no_child.rs b/tests/generated/border_no_child.rs
index abeb573d9..6ba789c42 100644
--- a/tests/generated/border_no_child.rs
+++ b/tests/generated/border_no_child.rs
@@ -3,10 +3,10 @@ fn border_no_child() {
     let layout = stretch::compute(
         &stretch::style::Node {
             border: stretch::geometry::Rect {
-                start: stretch::style::Dimension::Points(10.0000),
-                end: stretch::style::Dimension::Points(10.0000),
-                top: stretch::style::Dimension::Points(10.0000),
-                bottom: stretch::style::Dimension::Points(10.0000),
+                start: stretch::style::Dimension::Points(10f32),
+                end: stretch::style::Dimension::Points(10f32),
+                top: stretch::style::Dimension::Points(10f32),
+                bottom: stretch::style::Dimension::Points(10f32),
                 ..Default::default()
             },
             ..Default::default()
@@ -14,9 +14,8 @@ fn border_no_child() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 20.0000);
-    assert_eq!(layout.size.height, 20.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
+    assert_eq!(layout.size.width, 20f32);
+    assert_eq!(layout.size.height, 20f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
 }
diff --git a/tests/generated/border_stretch_child.rs b/tests/generated/border_stretch_child.rs
index 0efa11932..1805fbae5 100644
--- a/tests/generated/border_stretch_child.rs
+++ b/tests/generated/border_stretch_child.rs
@@ -3,37 +3,32 @@ fn border_stretch_child() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
-                ..Default::default()
-            },
-            border: stretch::geometry::Rect {
-                start: stretch::style::Dimension::Points(10.0000),
-                end: stretch::style::Dimension::Points(10.0000),
-                top: stretch::style::Dimension::Points(10.0000),
-                bottom: stretch::style::Dimension::Points(10.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
-                size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(10.0000),
-                    ..Default::default()
-                },
+                size: stretch::geometry::Size { width: stretch::style::Dimension::Points(10f32), ..Default::default() },
                 ..Default::default()
             }],
+            border: stretch::geometry::Rect {
+                start: stretch::style::Dimension::Points(10f32),
+                end: stretch::style::Dimension::Points(10f32),
+                top: stretch::style::Dimension::Points(10f32),
+                bottom: stretch::style::Dimension::Points(10f32),
+                ..Default::default()
+            },
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 80.0000);
-    assert_eq!(layout.children[0].location.x, 10.0000);
-    assert_eq!(layout.children[0].location.y, 10.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 80f32);
+    assert_eq!(layout.children[0usize].location.x, 10f32);
+    assert_eq!(layout.children[0usize].location.y, 10f32);
 }
diff --git a/tests/generated/child_min_max_width_flexing.rs b/tests/generated/child_min_max_width_flexing.rs
index 92917641c..71f5c5499 100644
--- a/tests/generated/child_min_max_width_flexing.rs
+++ b/tests/generated/child_min_max_width_flexing.rs
@@ -3,27 +3,27 @@ fn child_min_max_width_flexing() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(120.0000),
-                height: stretch::style::Dimension::Points(50.0000),
+                width: stretch::style::Dimension::Points(120f32),
+                height: stretch::style::Dimension::Points(50f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 0.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_shrink: 0f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     min_size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(60.0000),
+                        width: stretch::style::Dimension::Points(60f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 0.0000,
-                    flex_basis: stretch::style::Dimension::Percent(0.5000),
+                    flex_grow: 1f32,
+                    flex_shrink: 0f32,
+                    flex_basis: stretch::style::Dimension::Percent(0.5f32),
                     max_size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(20.0000),
+                        width: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -34,19 +34,16 @@ fn child_min_max_width_flexing() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 120.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 20.0000);
-    assert_eq!(layout.children[1].size.height, 50.0000);
-    assert_eq!(layout.children[1].location.x, 100.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 120f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].size.height, 50f32);
+    assert_eq!(layout.children[1usize].location.x, 100f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/container_with_unsized_child.rs b/tests/generated/container_with_unsized_child.rs
index 3c1ef5680..436c26370 100644
--- a/tests/generated/container_with_unsized_child.rs
+++ b/tests/generated/container_with_unsized_child.rs
@@ -3,8 +3,8 @@ fn container_with_unsized_child() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node { ..Default::default() }],
@@ -13,14 +13,12 @@ fn container_with_unsized_child() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/display_none.rs b/tests/generated/display_none.rs
index 99769f383..c4d409948 100644
--- a/tests/generated/display_none.rs
+++ b/tests/generated/display_none.rs
@@ -3,36 +3,29 @@ fn display_none() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
-                stretch::style::Node { flex_grow: 1.0000, ..Default::default() },
-                stretch::style::Node {
-                    display: stretch::style::Display::None,
-                    flex_grow: 1.0000,
-                    ..Default::default()
-                },
+                stretch::style::Node { flex_grow: 1f32, ..Default::default() },
+                stretch::style::Node { display: stretch::style::Display::None, flex_grow: 1f32, ..Default::default() },
             ],
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 0.0000);
-    assert_eq!(layout.children[1].size.height, 0.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 0f32);
+    assert_eq!(layout.children[1usize].size.height, 0f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/display_none_fixed_size.rs b/tests/generated/display_none_fixed_size.rs
index 7cd36c11c..f36419807 100644
--- a/tests/generated/display_none_fixed_size.rs
+++ b/tests/generated/display_none_fixed_size.rs
@@ -3,17 +3,17 @@ fn display_none_fixed_size() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
-                stretch::style::Node { flex_grow: 1.0000, ..Default::default() },
+                stretch::style::Node { flex_grow: 1f32, ..Default::default() },
                 stretch::style::Node {
                     display: stretch::style::Display::None,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(20.0000),
-                        height: stretch::style::Dimension::Points(20.0000),
+                        width: stretch::style::Dimension::Points(20f32),
+                        height: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -24,19 +24,16 @@ fn display_none_fixed_size() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 0.0000);
-    assert_eq!(layout.children[1].size.height, 0.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 0f32);
+    assert_eq!(layout.children[1usize].size.height, 0f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/display_none_with_child.rs b/tests/generated/display_none_with_child.rs
index 3c83845e5..b3a4832bb 100644
--- a/tests/generated/display_none_with_child.rs
+++ b/tests/generated/display_none_with_child.rs
@@ -3,29 +3,29 @@ fn display_none_with_child() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 1.0000,
-                    flex_basis: stretch::style::Dimension::Percent(0.0000),
+                    flex_grow: 1f32,
+                    flex_shrink: 1f32,
+                    flex_basis: stretch::style::Dimension::Percent(0f32),
                     ..Default::default()
                 },
                 stretch::style::Node {
                     display: stretch::style::Display::None,
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_shrink: 1.0000,
-                    flex_basis: stretch::style::Dimension::Percent(0.0000),
+                    flex_grow: 1f32,
+                    flex_shrink: 1f32,
+                    flex_basis: stretch::style::Dimension::Percent(0f32),
                     children: vec![stretch::style::Node {
-                        flex_grow: 1.0000,
-                        flex_shrink: 1.0000,
-                        flex_basis: stretch::style::Dimension::Percent(0.0000),
+                        flex_grow: 1f32,
+                        flex_shrink: 1f32,
+                        flex_basis: stretch::style::Dimension::Percent(0f32),
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(20.0000),
+                            width: stretch::style::Dimension::Points(20f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -33,9 +33,9 @@ fn display_none_with_child() {
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 1.0000,
-                    flex_basis: stretch::style::Dimension::Percent(0.0000),
+                    flex_grow: 1f32,
+                    flex_shrink: 1f32,
+                    flex_basis: stretch::style::Dimension::Percent(0f32),
                     ..Default::default()
                 },
             ],
@@ -44,29 +44,24 @@ fn display_none_with_child() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 0.0000);
-    assert_eq!(layout.children[1].size.height, 0.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].children[0].size.width, 0.0000);
-    assert_eq!(layout.children[1].children[0].size.height, 0.0000);
-    assert_eq!(layout.children[1].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[1].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[2].size.width, 50.0000);
-    assert_eq!(layout.children[2].size.height, 100.0000);
-    assert_eq!(layout.children[2].location.x, 50.0000);
-    assert_eq!(layout.children[2].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 0f32);
+    assert_eq!(layout.children[1usize].size.height, 0f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.height, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[2usize].size.width, 50f32);
+    assert_eq!(layout.children[2usize].size.height, 100f32);
+    assert_eq!(layout.children[2usize].location.x, 50f32);
+    assert_eq!(layout.children[2usize].location.y, 0f32);
 }
diff --git a/tests/generated/display_none_with_margin.rs b/tests/generated/display_none_with_margin.rs
index b485f257e..1d9e66a7e 100644
--- a/tests/generated/display_none_with_margin.rs
+++ b/tests/generated/display_none_with_margin.rs
@@ -3,47 +3,44 @@ fn display_none_with_margin() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     display: stretch::style::Display::None,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(20.0000),
-                        height: stretch::style::Dimension::Points(20.0000),
+                        width: stretch::style::Dimension::Points(20f32),
+                        height: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     margin: stretch::geometry::Rect {
-                        start: stretch::style::Dimension::Points(10.0000),
-                        end: stretch::style::Dimension::Points(10.0000),
-                        top: stretch::style::Dimension::Points(10.0000),
-                        bottom: stretch::style::Dimension::Points(10.0000),
+                        start: stretch::style::Dimension::Points(10f32),
+                        end: stretch::style::Dimension::Points(10f32),
+                        top: stretch::style::Dimension::Points(10f32),
+                        bottom: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
-                stretch::style::Node { flex_grow: 1.0000, ..Default::default() },
+                stretch::style::Node { flex_grow: 1f32, ..Default::default() },
             ],
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 0.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 0f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/display_none_with_position.rs b/tests/generated/display_none_with_position.rs
index 40d32c072..85bb49080 100644
--- a/tests/generated/display_none_with_position.rs
+++ b/tests/generated/display_none_with_position.rs
@@ -3,17 +3,17 @@ fn display_none_with_position() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
-                stretch::style::Node { flex_grow: 1.0000, ..Default::default() },
+                stretch::style::Node { flex_grow: 1f32, ..Default::default() },
                 stretch::style::Node {
                     display: stretch::style::Display::None,
-                    flex_grow: 1.0000,
+                    flex_grow: 1f32,
                     position: stretch::geometry::Rect {
-                        top: stretch::style::Dimension::Points(10.0000),
+                        top: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -24,19 +24,16 @@ fn display_none_with_position() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 0.0000);
-    assert_eq!(layout.children[1].size.height, 0.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 0f32);
+    assert_eq!(layout.children[1usize].size.height, 0f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_and_main_dimen_set_when_flexing.rs b/tests/generated/flex_basis_and_main_dimen_set_when_flexing.rs
index 431e109f0..906823641 100644
--- a/tests/generated/flex_basis_and_main_dimen_set_when_flexing.rs
+++ b/tests/generated/flex_basis_and_main_dimen_set_when_flexing.rs
@@ -2,24 +2,24 @@
 fn flex_basis_and_main_dimen_set_when_flexing() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(10.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(10f32),
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(10.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(10f32),
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(0.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(0f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -30,19 +30,16 @@ fn flex_basis_and_main_dimen_set_when_flexing() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 50.0000);
-    assert_eq!(layout.children[1].size.height, 50.0000);
-    assert_eq!(layout.children[1].location.x, 50.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 50f32);
+    assert_eq!(layout.children[1usize].size.height, 50f32);
+    assert_eq!(layout.children[1usize].location.x, 50f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_flex_grow_column.rs b/tests/generated/flex_basis_flex_grow_column.rs
index 19817f0ed..335d0f520 100644
--- a/tests/generated/flex_basis_flex_grow_column.rs
+++ b/tests/generated/flex_basis_flex_grow_column.rs
@@ -4,36 +4,33 @@ fn flex_basis_flex_grow_column() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(50.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(50f32),
                     ..Default::default()
                 },
-                stretch::style::Node { flex_grow: 1.0000, ..Default::default() },
+                stretch::style::Node { flex_grow: 1f32, ..Default::default() },
             ],
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 75.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 25.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 75.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 75f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 25f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 75f32);
 }
diff --git a/tests/generated/flex_basis_flex_grow_row.rs b/tests/generated/flex_basis_flex_grow_row.rs
index 12838c339..a171063ad 100644
--- a/tests/generated/flex_basis_flex_grow_row.rs
+++ b/tests/generated/flex_basis_flex_grow_row.rs
@@ -3,36 +3,33 @@ fn flex_basis_flex_grow_row() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(50.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(50f32),
                     ..Default::default()
                 },
-                stretch::style::Node { flex_grow: 1.0000, ..Default::default() },
+                stretch::style::Node { flex_grow: 1f32, ..Default::default() },
             ],
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 75.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 25.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 75.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 75f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 25f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 75f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_flex_shrink_column.rs b/tests/generated/flex_basis_flex_shrink_column.rs
index 8b5ad0465..0ffc115d4 100644
--- a/tests/generated/flex_basis_flex_shrink_column.rs
+++ b/tests/generated/flex_basis_flex_shrink_column.rs
@@ -4,32 +4,29 @@ fn flex_basis_flex_shrink_column() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
-                stretch::style::Node { flex_basis: stretch::style::Dimension::Points(100.0000), ..Default::default() },
-                stretch::style::Node { flex_basis: stretch::style::Dimension::Points(50.0000), ..Default::default() },
+                stretch::style::Node { flex_basis: stretch::style::Dimension::Points(100f32), ..Default::default() },
+                stretch::style::Node { flex_basis: stretch::style::Dimension::Points(50f32), ..Default::default() },
             ],
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 67.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 33.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 67.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 67f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 33f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 67f32);
 }
diff --git a/tests/generated/flex_basis_flex_shrink_row.rs b/tests/generated/flex_basis_flex_shrink_row.rs
index 4561b4943..c072d0bfd 100644
--- a/tests/generated/flex_basis_flex_shrink_row.rs
+++ b/tests/generated/flex_basis_flex_shrink_row.rs
@@ -3,32 +3,29 @@ fn flex_basis_flex_shrink_row() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
-                stretch::style::Node { flex_basis: stretch::style::Dimension::Points(100.0000), ..Default::default() },
-                stretch::style::Node { flex_basis: stretch::style::Dimension::Points(50.0000), ..Default::default() },
+                stretch::style::Node { flex_basis: stretch::style::Dimension::Points(100f32), ..Default::default() },
+                stretch::style::Node { flex_basis: stretch::style::Dimension::Points(50f32), ..Default::default() },
             ],
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 67.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 33.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 67.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 67f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 33f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 67f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_larger_than_content_column.rs b/tests/generated/flex_basis_larger_than_content_column.rs
index d987a995e..ab0e3e039 100644
--- a/tests/generated/flex_basis_larger_than_content_column.rs
+++ b/tests/generated/flex_basis_larger_than_content_column.rs
@@ -3,14 +3,14 @@ fn flex_basis_larger_than_content_column() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
-            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![stretch::style::Node {
                 flex_direction: stretch::style::FlexDirection::Column,
-                flex_basis: stretch::style::Dimension::Points(50.0000),
+                flex_basis: stretch::style::Dimension::Points(50f32),
                 children: vec![stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(100.0000),
-                        height: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(100f32),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -22,19 +22,16 @@ fn flex_basis_larger_than_content_column() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_larger_than_content_row.rs b/tests/generated/flex_basis_larger_than_content_row.rs
index 520b5ddd4..bf8774085 100644
--- a/tests/generated/flex_basis_larger_than_content_row.rs
+++ b/tests/generated/flex_basis_larger_than_content_row.rs
@@ -2,14 +2,14 @@
 fn flex_basis_larger_than_content_row() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![stretch::style::Node {
                 flex_direction: stretch::style::FlexDirection::Column,
-                flex_basis: stretch::style::Dimension::Points(50.0000),
+                flex_basis: stretch::style::Dimension::Points(50f32),
                 children: vec![stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
-                        height: stretch::style::Dimension::Points(100.0000),
+                        width: stretch::style::Dimension::Points(10f32),
+                        height: stretch::style::Dimension::Points(100f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -21,19 +21,16 @@ fn flex_basis_larger_than_content_row() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_overrides_main_size.rs b/tests/generated/flex_basis_overrides_main_size.rs
index 12d696388..a92f13374 100644
--- a/tests/generated/flex_basis_overrides_main_size.rs
+++ b/tests/generated/flex_basis_overrides_main_size.rs
@@ -3,32 +3,32 @@ fn flex_basis_overrides_main_size() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(50.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(50f32),
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(20.0000),
+                        width: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_grow: 1.0000,
+                    flex_grow: 1f32,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_grow: 1.0000,
+                    flex_grow: 1f32,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -39,24 +39,20 @@ fn flex_basis_overrides_main_size() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 60.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 20.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 60.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[2].size.width, 20.0000);
-    assert_eq!(layout.children[2].size.height, 100.0000);
-    assert_eq!(layout.children[2].location.x, 80.0000);
-    assert_eq!(layout.children[2].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 60f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 60f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[2usize].size.width, 20f32);
+    assert_eq!(layout.children[2usize].size.height, 100f32);
+    assert_eq!(layout.children[2usize].location.x, 80f32);
+    assert_eq!(layout.children[2usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_slightly_smaller_then_content_with_flex_grow_large_size.rs b/tests/generated/flex_basis_slightly_smaller_then_content_with_flex_grow_large_size.rs
index 253cd3b7f..252d1a9fd 100644
--- a/tests/generated/flex_basis_slightly_smaller_then_content_with_flex_grow_large_size.rs
+++ b/tests/generated/flex_basis_slightly_smaller_then_content_with_flex_grow_large_size.rs
@@ -2,16 +2,16 @@
 fn flex_basis_slightly_smaller_then_content_with_flex_grow_large_size() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(60.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(60f32),
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(70.0000),
-                            height: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(70f32),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -20,12 +20,12 @@ fn flex_basis_slightly_smaller_then_content_with_flex_grow_large_size() {
                 },
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(20.0000),
-                            height: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(20f32),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -38,29 +38,24 @@ fn flex_basis_slightly_smaller_then_content_with_flex_grow_large_size() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 80.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 20.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 80.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].children[0].size.width, 20.0000);
-    assert_eq!(layout.children[1].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[1].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[1].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 80f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 80f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_smaller_than_content_column.rs b/tests/generated/flex_basis_smaller_than_content_column.rs
index a993b274c..6a495ce83 100644
--- a/tests/generated/flex_basis_smaller_than_content_column.rs
+++ b/tests/generated/flex_basis_smaller_than_content_column.rs
@@ -1,16 +1,17 @@
 #[test]
+#[ignore]
 fn flex_basis_smaller_than_content_column() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
-            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![stretch::style::Node {
                 flex_direction: stretch::style::FlexDirection::Column,
-                flex_basis: stretch::style::Dimension::Points(50.0000),
+                flex_basis: stretch::style::Dimension::Points(50f32),
                 children: vec![stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(100.0000),
-                        height: stretch::style::Dimension::Points(100.0000),
+                        width: stretch::style::Dimension::Points(100f32),
+                        height: stretch::style::Dimension::Points(100f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -22,19 +23,16 @@ fn flex_basis_smaller_than_content_column() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_smaller_than_content_row.rs b/tests/generated/flex_basis_smaller_than_content_row.rs
index e592108c4..f18c0b6df 100644
--- a/tests/generated/flex_basis_smaller_than_content_row.rs
+++ b/tests/generated/flex_basis_smaller_than_content_row.rs
@@ -2,14 +2,14 @@
 fn flex_basis_smaller_than_content_row() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![stretch::style::Node {
                 flex_direction: stretch::style::FlexDirection::Column,
-                flex_basis: stretch::style::Dimension::Points(50.0000),
+                flex_basis: stretch::style::Dimension::Points(50f32),
                 children: vec![stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(100.0000),
-                        height: stretch::style::Dimension::Points(100.0000),
+                        width: stretch::style::Dimension::Points(100f32),
+                        height: stretch::style::Dimension::Points(100f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -21,19 +21,16 @@ fn flex_basis_smaller_than_content_row() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_smaller_than_main_dimen_column.rs b/tests/generated/flex_basis_smaller_than_main_dimen_column.rs
index 956e64a75..7d8286d75 100644
--- a/tests/generated/flex_basis_smaller_than_main_dimen_column.rs
+++ b/tests/generated/flex_basis_smaller_than_main_dimen_column.rs
@@ -3,12 +3,12 @@ fn flex_basis_smaller_than_main_dimen_column() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
-            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![stretch::style::Node {
-                flex_basis: stretch::style::Dimension::Points(10.0000),
+                flex_basis: stretch::style::Dimension::Points(10f32),
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(50.0000),
-                    height: stretch::style::Dimension::Points(50.0000),
+                    width: stretch::style::Dimension::Points(50f32),
+                    height: stretch::style::Dimension::Points(50f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -18,14 +18,12 @@ fn flex_basis_smaller_than_main_dimen_column() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 50.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 50f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_smaller_than_main_dimen_row.rs b/tests/generated/flex_basis_smaller_than_main_dimen_row.rs
index ae0d843e7..5c7edf4e4 100644
--- a/tests/generated/flex_basis_smaller_than_main_dimen_row.rs
+++ b/tests/generated/flex_basis_smaller_than_main_dimen_row.rs
@@ -2,12 +2,12 @@
 fn flex_basis_smaller_than_main_dimen_row() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![stretch::style::Node {
-                flex_basis: stretch::style::Dimension::Points(10.0000),
+                flex_basis: stretch::style::Dimension::Points(10f32),
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(50.0000),
-                    height: stretch::style::Dimension::Points(50.0000),
+                    width: stretch::style::Dimension::Points(50f32),
+                    height: stretch::style::Dimension::Points(50f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -17,14 +17,12 @@ fn flex_basis_smaller_than_main_dimen_row() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_smaller_then_content_with_flex_grow_large_size.rs b/tests/generated/flex_basis_smaller_then_content_with_flex_grow_large_size.rs
index 28a82e45b..e0480d14d 100644
--- a/tests/generated/flex_basis_smaller_then_content_with_flex_grow_large_size.rs
+++ b/tests/generated/flex_basis_smaller_then_content_with_flex_grow_large_size.rs
@@ -2,16 +2,16 @@
 fn flex_basis_smaller_then_content_with_flex_grow_large_size() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(70.0000),
-                            height: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(70f32),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -20,12 +20,12 @@ fn flex_basis_smaller_then_content_with_flex_grow_large_size() {
                 },
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(20.0000),
-                            height: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(20f32),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -38,29 +38,24 @@ fn flex_basis_smaller_then_content_with_flex_grow_large_size() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 30.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 70.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].children[0].size.width, 20.0000);
-    assert_eq!(layout.children[1].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[1].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[1].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 30f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 70f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_smaller_then_content_with_flex_grow_small_size.rs b/tests/generated/flex_basis_smaller_then_content_with_flex_grow_small_size.rs
index 93807c39e..6f22b8bb2 100644
--- a/tests/generated/flex_basis_smaller_then_content_with_flex_grow_small_size.rs
+++ b/tests/generated/flex_basis_smaller_then_content_with_flex_grow_small_size.rs
@@ -2,16 +2,16 @@
 fn flex_basis_smaller_then_content_with_flex_grow_small_size() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(10.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(10f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(70.0000),
-                            height: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(70f32),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -20,12 +20,12 @@ fn flex_basis_smaller_then_content_with_flex_grow_small_size() {
                 },
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(20.0000),
-                            height: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(20f32),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -38,29 +38,24 @@ fn flex_basis_smaller_then_content_with_flex_grow_small_size() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 10.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 20.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 70.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].children[0].size.width, 20.0000);
-    assert_eq!(layout.children[1].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[1].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[1].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 10f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 70f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_smaller_then_content_with_flex_grow_unconstraint_size.rs b/tests/generated/flex_basis_smaller_then_content_with_flex_grow_unconstraint_size.rs
index 616b1797d..520e22928 100644
--- a/tests/generated/flex_basis_smaller_then_content_with_flex_grow_unconstraint_size.rs
+++ b/tests/generated/flex_basis_smaller_then_content_with_flex_grow_unconstraint_size.rs
@@ -5,12 +5,12 @@ fn flex_basis_smaller_then_content_with_flex_grow_unconstraint_size() {
             children: vec![
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(70.0000),
-                            height: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(70f32),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -19,12 +19,12 @@ fn flex_basis_smaller_then_content_with_flex_grow_unconstraint_size() {
                 },
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(20.0000),
-                            height: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(20f32),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -37,29 +37,24 @@ fn flex_basis_smaller_then_content_with_flex_grow_unconstraint_size() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 90.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 20.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 70.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].children[0].size.width, 20.0000);
-    assert_eq!(layout.children[1].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[1].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[1].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 90f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 70f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_smaller_then_content_with_flex_grow_very_large_size.rs b/tests/generated/flex_basis_smaller_then_content_with_flex_grow_very_large_size.rs
index 0aea13880..9a6a63627 100644
--- a/tests/generated/flex_basis_smaller_then_content_with_flex_grow_very_large_size.rs
+++ b/tests/generated/flex_basis_smaller_then_content_with_flex_grow_very_large_size.rs
@@ -2,16 +2,16 @@
 fn flex_basis_smaller_then_content_with_flex_grow_very_large_size() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(200.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(200f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(70.0000),
-                            height: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(70f32),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -20,12 +20,12 @@ fn flex_basis_smaller_then_content_with_flex_grow_very_large_size() {
                 },
                 stretch::style::Node {
                     flex_direction: stretch::style::FlexDirection::Column,
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     children: vec![stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(20.0000),
-                            height: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(20f32),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -38,29 +38,24 @@ fn flex_basis_smaller_then_content_with_flex_grow_very_large_size() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 200.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 70.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 100.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].children[0].size.width, 20.0000);
-    assert_eq!(layout.children[1].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[1].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[1].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 200f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 70f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 100f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_unconstraint_column.rs b/tests/generated/flex_basis_unconstraint_column.rs
index 413cf641c..41f0e5e97 100644
--- a/tests/generated/flex_basis_unconstraint_column.rs
+++ b/tests/generated/flex_basis_unconstraint_column.rs
@@ -4,9 +4,9 @@ fn flex_basis_unconstraint_column() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
             children: vec![stretch::style::Node {
-                flex_basis: stretch::style::Dimension::Points(50.0000),
+                flex_basis: stretch::style::Dimension::Points(50f32),
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(100.0000),
+                    width: stretch::style::Dimension::Points(100f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -16,14 +16,12 @@ fn flex_basis_unconstraint_column() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_basis_unconstraint_row.rs b/tests/generated/flex_basis_unconstraint_row.rs
index 7e4752bcb..fa4c701a0 100644
--- a/tests/generated/flex_basis_unconstraint_row.rs
+++ b/tests/generated/flex_basis_unconstraint_row.rs
@@ -3,9 +3,9 @@ fn flex_basis_unconstraint_row() {
     let layout = stretch::compute(
         &stretch::style::Node {
             children: vec![stretch::style::Node {
-                flex_basis: stretch::style::Dimension::Points(50.0000),
+                flex_basis: stretch::style::Dimension::Points(50f32),
                 size: stretch::geometry::Size {
-                    height: stretch::style::Dimension::Points(100.0000),
+                    height: stretch::style::Dimension::Points(100f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -15,14 +15,12 @@ fn flex_basis_unconstraint_row() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 0.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 0f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_direction_column.rs b/tests/generated/flex_direction_column.rs
index aa3963a3e..d3341ebda 100644
--- a/tests/generated/flex_direction_column.rs
+++ b/tests/generated/flex_direction_column.rs
@@ -4,28 +4,28 @@ fn flex_direction_column() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -36,24 +36,20 @@ fn flex_direction_column() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 10.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 10.0000);
-
-    assert_eq!(layout.children[2].size.width, 100.0000);
-    assert_eq!(layout.children[2].size.height, 10.0000);
-    assert_eq!(layout.children[2].location.x, 0.0000);
-    assert_eq!(layout.children[2].location.y, 20.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 10f32);
+    assert_eq!(layout.children[2usize].size.width, 100f32);
+    assert_eq!(layout.children[2usize].size.height, 10f32);
+    assert_eq!(layout.children[2usize].location.x, 0f32);
+    assert_eq!(layout.children[2usize].location.y, 20f32);
 }
diff --git a/tests/generated/flex_direction_column_no_height.rs b/tests/generated/flex_direction_column_no_height.rs
index dd2ee6e71..5ce252fa6 100644
--- a/tests/generated/flex_direction_column_no_height.rs
+++ b/tests/generated/flex_direction_column_no_height.rs
@@ -3,25 +3,25 @@ fn flex_direction_column_no_height() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -32,24 +32,20 @@ fn flex_direction_column_no_height() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 30.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 10.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 10.0000);
-
-    assert_eq!(layout.children[2].size.width, 100.0000);
-    assert_eq!(layout.children[2].size.height, 10.0000);
-    assert_eq!(layout.children[2].location.x, 0.0000);
-    assert_eq!(layout.children[2].location.y, 20.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 30f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 10f32);
+    assert_eq!(layout.children[2usize].size.width, 100f32);
+    assert_eq!(layout.children[2usize].size.height, 10f32);
+    assert_eq!(layout.children[2usize].location.x, 0f32);
+    assert_eq!(layout.children[2usize].location.y, 20f32);
 }
diff --git a/tests/generated/flex_direction_column_reverse.rs b/tests/generated/flex_direction_column_reverse.rs
index 7b9db1898..40a7c6f56 100644
--- a/tests/generated/flex_direction_column_reverse.rs
+++ b/tests/generated/flex_direction_column_reverse.rs
@@ -4,28 +4,28 @@ fn flex_direction_column_reverse() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::ColumnReverse,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -36,24 +36,20 @@ fn flex_direction_column_reverse() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 90.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 10.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 80.0000);
-
-    assert_eq!(layout.children[2].size.width, 100.0000);
-    assert_eq!(layout.children[2].size.height, 10.0000);
-    assert_eq!(layout.children[2].location.x, 0.0000);
-    assert_eq!(layout.children[2].location.y, 70.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 90f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 80f32);
+    assert_eq!(layout.children[2usize].size.width, 100f32);
+    assert_eq!(layout.children[2usize].size.height, 10f32);
+    assert_eq!(layout.children[2usize].location.x, 0f32);
+    assert_eq!(layout.children[2usize].location.y, 70f32);
 }
diff --git a/tests/generated/flex_direction_row.rs b/tests/generated/flex_direction_row.rs
index 2082638cc..d37b2eeb1 100644
--- a/tests/generated/flex_direction_row.rs
+++ b/tests/generated/flex_direction_row.rs
@@ -3,28 +3,28 @@ fn flex_direction_row() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -35,24 +35,20 @@ fn flex_direction_row() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 10.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 10.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[2].size.width, 10.0000);
-    assert_eq!(layout.children[2].size.height, 100.0000);
-    assert_eq!(layout.children[2].location.x, 20.0000);
-    assert_eq!(layout.children[2].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 10f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 10f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[2usize].size.width, 10f32);
+    assert_eq!(layout.children[2usize].size.height, 100f32);
+    assert_eq!(layout.children[2usize].location.x, 20f32);
+    assert_eq!(layout.children[2usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_direction_row_no_width.rs b/tests/generated/flex_direction_row_no_width.rs
index 9a7538b29..83649ed6d 100644
--- a/tests/generated/flex_direction_row_no_width.rs
+++ b/tests/generated/flex_direction_row_no_width.rs
@@ -2,25 +2,25 @@
 fn flex_direction_row_no_width() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -31,24 +31,20 @@ fn flex_direction_row_no_width() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 30.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 10.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 10.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[2].size.width, 10.0000);
-    assert_eq!(layout.children[2].size.height, 100.0000);
-    assert_eq!(layout.children[2].location.x, 20.0000);
-    assert_eq!(layout.children[2].location.y, 0.0000);
+    assert_eq!(layout.size.width, 30f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 10f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 10f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[2usize].size.width, 10f32);
+    assert_eq!(layout.children[2usize].size.height, 100f32);
+    assert_eq!(layout.children[2usize].location.x, 20f32);
+    assert_eq!(layout.children[2usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_direction_row_reverse.rs b/tests/generated/flex_direction_row_reverse.rs
index d3bbcb231..ac34817d4 100644
--- a/tests/generated/flex_direction_row_reverse.rs
+++ b/tests/generated/flex_direction_row_reverse.rs
@@ -4,28 +4,28 @@ fn flex_direction_row_reverse() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::RowReverse,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(10.0000),
+                        width: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -36,24 +36,20 @@ fn flex_direction_row_reverse() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 10.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 90.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 10.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 80.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[2].size.width, 10.0000);
-    assert_eq!(layout.children[2].size.height, 100.0000);
-    assert_eq!(layout.children[2].location.x, 70.0000);
-    assert_eq!(layout.children[2].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 10f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 90f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 10f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 80f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[2usize].size.width, 10f32);
+    assert_eq!(layout.children[2usize].size.height, 100f32);
+    assert_eq!(layout.children[2usize].location.x, 70f32);
+    assert_eq!(layout.children[2usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_grow_child.rs b/tests/generated/flex_grow_child.rs
index 2790a654e..69b667249 100644
--- a/tests/generated/flex_grow_child.rs
+++ b/tests/generated/flex_grow_child.rs
@@ -3,10 +3,10 @@ fn flex_grow_child() {
     let layout = stretch::compute(
         &stretch::style::Node {
             children: vec![stretch::style::Node {
-                flex_grow: 1.0000,
-                flex_basis: stretch::style::Dimension::Points(0.0000),
+                flex_grow: 1f32,
+                flex_basis: stretch::style::Dimension::Points(0f32),
                 size: stretch::geometry::Size {
-                    height: stretch::style::Dimension::Points(100.0000),
+                    height: stretch::style::Dimension::Points(100f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -16,14 +16,12 @@ fn flex_grow_child() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 0.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 0f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_grow_flex_basis_percent_min_max.rs b/tests/generated/flex_grow_flex_basis_percent_min_max.rs
index 353ddc3d2..ad43e7672 100644
--- a/tests/generated/flex_grow_flex_basis_percent_min_max.rs
+++ b/tests/generated/flex_grow_flex_basis_percent_min_max.rs
@@ -2,33 +2,33 @@
 fn flex_grow_flex_basis_percent_min_max() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(120.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(120f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 0.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_shrink: 0f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(20.0000),
+                        height: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     min_size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(60.0000),
+                        width: stretch::style::Dimension::Points(60f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 0.0000,
-                    flex_basis: stretch::style::Dimension::Percent(0.5000),
+                    flex_grow: 1f32,
+                    flex_shrink: 0f32,
+                    flex_basis: stretch::style::Dimension::Percent(0.5f32),
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(20.0000),
-                        height: stretch::style::Dimension::Points(20.0000),
+                        width: stretch::style::Dimension::Points(20f32),
+                        height: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     max_size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(20.0000),
+                        width: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -39,19 +39,16 @@ fn flex_grow_flex_basis_percent_min_max() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 120.0000);
-    assert_eq!(layout.size.height, 20.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 20.0000);
-    assert_eq!(layout.children[1].size.height, 20.0000);
-    assert_eq!(layout.children[1].location.x, 100.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 120f32);
+    assert_eq!(layout.size.height, 20f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 20f32);
+    assert_eq!(layout.children[1usize].size.height, 20f32);
+    assert_eq!(layout.children[1usize].location.x, 100f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_grow_height_maximized.rs b/tests/generated/flex_grow_height_maximized.rs
index aa1fb3d1c..c615a0da2 100644
--- a/tests/generated/flex_grow_height_maximized.rs
+++ b/tests/generated/flex_grow_height_maximized.rs
@@ -4,30 +4,30 @@ fn flex_grow_height_maximized() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(500.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(500f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 flex_direction: stretch::style::FlexDirection::Column,
-                flex_grow: 1.0000,
+                flex_grow: 1f32,
                 min_size: stretch::geometry::Size {
-                    height: stretch::style::Dimension::Points(100.0000),
+                    height: stretch::style::Dimension::Points(100f32),
                     ..Default::default()
                 },
                 max_size: stretch::geometry::Size {
-                    height: stretch::style::Dimension::Points(500.0000),
+                    height: stretch::style::Dimension::Points(500f32),
                     ..Default::default()
                 },
                 children: vec![
                     stretch::style::Node {
-                        flex_grow: 1.0000,
-                        flex_basis: stretch::style::Dimension::Points(200.0000),
+                        flex_grow: 1f32,
+                        flex_basis: stretch::style::Dimension::Points(200f32),
                         ..Default::default()
                     },
                     stretch::style::Node {
                         size: stretch::geometry::Size {
-                            height: stretch::style::Dimension::Points(100.0000),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -40,24 +40,20 @@ fn flex_grow_height_maximized() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 500.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 500.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 400.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[1].size.width, 100.0000);
-    assert_eq!(layout.children[0].children[1].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[1].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[1].location.y, 400.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 500f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 500f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 400f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[1usize].location.y, 400f32);
 }
diff --git a/tests/generated/flex_grow_in_at_most_container.rs b/tests/generated/flex_grow_in_at_most_container.rs
index e8d9a75e0..db8451854 100644
--- a/tests/generated/flex_grow_in_at_most_container.rs
+++ b/tests/generated/flex_grow_in_at_most_container.rs
@@ -4,14 +4,14 @@ fn flex_grow_in_at_most_container() {
         &stretch::style::Node {
             align_items: stretch::style::AlignItems::FlexStart,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 children: vec![stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(0.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(0f32),
                     ..Default::default()
                 }],
                 ..Default::default()
@@ -21,19 +21,16 @@ fn flex_grow_in_at_most_container() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 0.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 0f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_grow_less_than_factor_one.rs b/tests/generated/flex_grow_less_than_factor_one.rs
index 2c64f9a6a..8559d76c2 100644
--- a/tests/generated/flex_grow_less_than_factor_one.rs
+++ b/tests/generated/flex_grow_less_than_factor_one.rs
@@ -3,43 +3,39 @@ fn flex_grow_less_than_factor_one() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(500.0000),
-                height: stretch::style::Dimension::Points(200.0000),
+                width: stretch::style::Dimension::Points(500f32),
+                height: stretch::style::Dimension::Points(200f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 0.2000,
-                    flex_shrink: 0.0000,
-                    flex_basis: stretch::style::Dimension::Points(40.0000),
+                    flex_grow: 0.2f32,
+                    flex_shrink: 0f32,
+                    flex_basis: stretch::style::Dimension::Points(40f32),
                     ..Default::default()
                 },
-                stretch::style::Node { flex_grow: 0.2000, flex_shrink: 0.0000, ..Default::default() },
-                stretch::style::Node { flex_grow: 0.4000, flex_shrink: 0.0000, ..Default::default() },
+                stretch::style::Node { flex_grow: 0.2f32, flex_shrink: 0f32, ..Default::default() },
+                stretch::style::Node { flex_grow: 0.4f32, flex_shrink: 0f32, ..Default::default() },
             ],
             ..Default::default()
         },
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 500.0000);
-    assert_eq!(layout.size.height, 200.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 132.0000);
-    assert_eq!(layout.children[0].size.height, 200.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 92.0000);
-    assert_eq!(layout.children[1].size.height, 200.0000);
-    assert_eq!(layout.children[1].location.x, 132.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[2].size.width, 184.0000);
-    assert_eq!(layout.children[2].size.height, 200.0000);
-    assert_eq!(layout.children[2].location.x, 224.0000);
-    assert_eq!(layout.children[2].location.y, 0.0000);
+    assert_eq!(layout.size.width, 500f32);
+    assert_eq!(layout.size.height, 200f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 132f32);
+    assert_eq!(layout.children[0usize].size.height, 200f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 92f32);
+    assert_eq!(layout.children[1usize].size.height, 200f32);
+    assert_eq!(layout.children[1usize].location.x, 132f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[2usize].size.width, 184f32);
+    assert_eq!(layout.children[2usize].size.height, 200f32);
+    assert_eq!(layout.children[2usize].location.x, 224f32);
+    assert_eq!(layout.children[2usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_grow_root_minimized.rs b/tests/generated/flex_grow_root_minimized.rs
index d5d9bc236..52faf95eb 100644
--- a/tests/generated/flex_grow_root_minimized.rs
+++ b/tests/generated/flex_grow_root_minimized.rs
@@ -3,35 +3,35 @@ fn flex_grow_root_minimized() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             min_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(100.0000),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             max_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(500.0000),
+                height: stretch::style::Dimension::Points(500f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 flex_direction: stretch::style::FlexDirection::Column,
-                flex_grow: 1.0000,
+                flex_grow: 1f32,
                 min_size: stretch::geometry::Size {
-                    height: stretch::style::Dimension::Points(100.0000),
+                    height: stretch::style::Dimension::Points(100f32),
                     ..Default::default()
                 },
                 max_size: stretch::geometry::Size {
-                    height: stretch::style::Dimension::Points(500.0000),
+                    height: stretch::style::Dimension::Points(500f32),
                     ..Default::default()
                 },
                 children: vec![
                     stretch::style::Node {
-                        flex_grow: 1.0000,
-                        flex_basis: stretch::style::Dimension::Points(200.0000),
+                        flex_grow: 1f32,
+                        flex_basis: stretch::style::Dimension::Points(200f32),
                         ..Default::default()
                     },
                     stretch::style::Node {
                         size: stretch::geometry::Size {
-                            height: stretch::style::Dimension::Points(100.0000),
+                            height: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -44,24 +44,20 @@ fn flex_grow_root_minimized() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 300.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 300.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 200.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[1].size.width, 100.0000);
-    assert_eq!(layout.children[0].children[1].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[1].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[1].location.y, 200.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 300f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 300f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 200f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[1usize].location.y, 200f32);
 }
diff --git a/tests/generated/flex_grow_shrink_at_most.rs b/tests/generated/flex_grow_shrink_at_most.rs
index 93f514f4c..588dddc98 100644
--- a/tests/generated/flex_grow_shrink_at_most.rs
+++ b/tests/generated/flex_grow_shrink_at_most.rs
@@ -3,12 +3,12 @@ fn flex_grow_shrink_at_most() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
-                children: vec![stretch::style::Node { flex_grow: 1.0000, flex_shrink: 1.0000, ..Default::default() }],
+                children: vec![stretch::style::Node { flex_grow: 1f32, flex_shrink: 1f32, ..Default::default() }],
                 ..Default::default()
             }],
             ..Default::default()
@@ -16,19 +16,16 @@ fn flex_grow_shrink_at_most() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_grow_to_min.rs b/tests/generated/flex_grow_to_min.rs
index 5c9549700..08078df66 100644
--- a/tests/generated/flex_grow_to_min.rs
+++ b/tests/generated/flex_grow_to_min.rs
@@ -3,20 +3,20 @@ fn flex_grow_to_min() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             min_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(100.0000),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             max_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(500.0000),
+                height: stretch::style::Dimension::Points(500f32),
                 ..Default::default()
             },
             children: vec![
-                stretch::style::Node { flex_grow: 1.0000, flex_shrink: 1.0000, ..Default::default() },
+                stretch::style::Node { flex_grow: 1f32, flex_shrink: 1f32, ..Default::default() },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(50.0000),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -27,19 +27,16 @@ fn flex_grow_to_min() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 50.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 50.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 50f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 50f32);
 }
diff --git a/tests/generated/flex_grow_within_constrained_max_column.rs b/tests/generated/flex_grow_within_constrained_max_column.rs
index 929ddb2e6..c2e7bf4d8 100644
--- a/tests/generated/flex_grow_within_constrained_max_column.rs
+++ b/tests/generated/flex_grow_within_constrained_max_column.rs
@@ -3,20 +3,20 @@ fn flex_grow_within_constrained_max_column() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             max_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(100.0000),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
-                    flex_shrink: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(100.0000),
+                    flex_shrink: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(100f32),
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(50.0000),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -27,19 +27,16 @@ fn flex_grow_within_constrained_max_column() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 67.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 33.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 67.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 67f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 33f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 67f32);
 }
diff --git a/tests/generated/flex_grow_within_constrained_max_row.rs b/tests/generated/flex_grow_within_constrained_max_row.rs
index ad5253330..2e87ae20b 100644
--- a/tests/generated/flex_grow_within_constrained_max_row.rs
+++ b/tests/generated/flex_grow_within_constrained_max_row.rs
@@ -3,25 +3,25 @@ fn flex_grow_within_constrained_max_row() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(200.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(200f32), ..Default::default() },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    height: stretch::style::Dimension::Points(100.0000),
+                    height: stretch::style::Dimension::Points(100f32),
                     ..Default::default()
                 },
                 max_size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(100.0000),
+                    width: stretch::style::Dimension::Points(100f32),
                     ..Default::default()
                 },
                 children: vec![
                     stretch::style::Node {
-                        flex_shrink: 1.0000,
-                        flex_basis: stretch::style::Dimension::Points(100.0000),
+                        flex_shrink: 1f32,
+                        flex_basis: stretch::style::Dimension::Points(100f32),
                         ..Default::default()
                     },
                     stretch::style::Node {
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(50.0000),
+                            width: stretch::style::Dimension::Points(50f32),
                             ..Default::default()
                         },
                         ..Default::default()
@@ -34,24 +34,20 @@ fn flex_grow_within_constrained_max_row() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 200.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 67.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[1].size.width, 33.0000);
-    assert_eq!(layout.children[0].children[1].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[1].location.x, 67.0000);
-    assert_eq!(layout.children[0].children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 200f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 67f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[1usize].size.width, 33f32);
+    assert_eq!(layout.children[0usize].children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[1usize].location.x, 67f32);
+    assert_eq!(layout.children[0usize].children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_grow_within_constrained_max_width.rs b/tests/generated/flex_grow_within_constrained_max_width.rs
index 0bcf37eaf..be23b1aa1 100644
--- a/tests/generated/flex_grow_within_constrained_max_width.rs
+++ b/tests/generated/flex_grow_within_constrained_max_width.rs
@@ -4,19 +4,19 @@ fn flex_grow_within_constrained_max_width() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(200.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(200f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 max_size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(300.0000),
+                    width: stretch::style::Dimension::Points(300f32),
                     ..Default::default()
                 },
                 children: vec![stretch::style::Node {
-                    flex_grow: 1.0000,
+                    flex_grow: 1f32,
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(20.0000),
+                        height: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -28,19 +28,16 @@ fn flex_grow_within_constrained_max_width() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 200.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 200.0000);
-    assert_eq!(layout.children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 200.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 200f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 200f32);
+    assert_eq!(layout.children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 200f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_grow_within_constrained_min_column.rs b/tests/generated/flex_grow_within_constrained_min_column.rs
index ce15d7127..985e97a00 100644
--- a/tests/generated/flex_grow_within_constrained_min_column.rs
+++ b/tests/generated/flex_grow_within_constrained_min_column.rs
@@ -4,14 +4,14 @@ fn flex_grow_within_constrained_min_column() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
             min_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(100.0000),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
-                stretch::style::Node { flex_grow: 1.0000, ..Default::default() },
+                stretch::style::Node { flex_grow: 1f32, ..Default::default() },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(50.0000),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -22,19 +22,16 @@ fn flex_grow_within_constrained_min_column() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 0.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 0.0000);
-    assert_eq!(layout.children[1].size.height, 50.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 50.0000);
+    assert_eq!(layout.size.width, 0f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 0f32);
+    assert_eq!(layout.children[1usize].size.height, 50f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 50f32);
 }
diff --git a/tests/generated/flex_grow_within_constrained_min_max_column.rs b/tests/generated/flex_grow_within_constrained_min_max_column.rs
index d990ae618..49aa7817a 100644
--- a/tests/generated/flex_grow_within_constrained_min_max_column.rs
+++ b/tests/generated/flex_grow_within_constrained_min_max_column.rs
@@ -3,14 +3,14 @@ fn flex_grow_within_constrained_min_max_column() {
     let layout = stretch::compute(
         &stretch::style::Node {
             min_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(100.0000),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
-                stretch::style::Node { flex_grow: 1.0000, ..Default::default() },
+                stretch::style::Node { flex_grow: 1f32, ..Default::default() },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(50.0000),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -21,19 +21,16 @@ fn flex_grow_within_constrained_min_max_column() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 0.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 0.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 0.0000);
-    assert_eq!(layout.children[1].size.height, 50.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 0f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 0f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 0f32);
+    assert_eq!(layout.children[1usize].size.height, 50f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_grow_within_constrained_min_row.rs b/tests/generated/flex_grow_within_constrained_min_row.rs
index dcbb4fe6a..654d65a40 100644
--- a/tests/generated/flex_grow_within_constrained_min_row.rs
+++ b/tests/generated/flex_grow_within_constrained_min_row.rs
@@ -2,16 +2,16 @@
 fn flex_grow_within_constrained_min_row() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100f32), ..Default::default() },
             min_size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
-                stretch::style::Node { flex_grow: 1.0000, ..Default::default() },
+                stretch::style::Node { flex_grow: 1f32, ..Default::default() },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -22,19 +22,16 @@ fn flex_grow_within_constrained_min_row() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 50.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 50.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 50f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 50f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_grow_within_max_width.rs b/tests/generated/flex_grow_within_max_width.rs
index be186066c..bafa595af 100644
--- a/tests/generated/flex_grow_within_max_width.rs
+++ b/tests/generated/flex_grow_within_max_width.rs
@@ -4,19 +4,19 @@ fn flex_grow_within_max_width() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(200.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(200f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 max_size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(100.0000),
+                    width: stretch::style::Dimension::Points(100f32),
                     ..Default::default()
                 },
                 children: vec![stretch::style::Node {
-                    flex_grow: 1.0000,
+                    flex_grow: 1f32,
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(20.0000),
+                        height: stretch::style::Dimension::Points(20f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -28,19 +28,16 @@ fn flex_grow_within_max_width() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 200.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
+    assert_eq!(layout.size.width, 200f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_root_ignored.rs b/tests/generated/flex_root_ignored.rs
index ed3d4b2b5..3dbaed560 100644
--- a/tests/generated/flex_root_ignored.rs
+++ b/tests/generated/flex_root_ignored.rs
@@ -3,24 +3,24 @@ fn flex_root_ignored() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             min_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(100.0000),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             max_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(500.0000),
+                height: stretch::style::Dimension::Points(500f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_basis: stretch::style::Dimension::Points(200.0000),
+                    flex_grow: 1f32,
+                    flex_basis: stretch::style::Dimension::Points(200f32),
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(100.0000),
+                        height: stretch::style::Dimension::Points(100f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -31,19 +31,16 @@ fn flex_root_ignored() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 300.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 200.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 200.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 300f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 200f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 200f32);
 }
diff --git a/tests/generated/flex_shrink_by_outer_margin_with_max_size.rs b/tests/generated/flex_shrink_by_outer_margin_with_max_size.rs
index db748e8ce..420da9dec 100644
--- a/tests/generated/flex_shrink_by_outer_margin_with_max_size.rs
+++ b/tests/generated/flex_shrink_by_outer_margin_with_max_size.rs
@@ -3,19 +3,19 @@ fn flex_shrink_by_outer_margin_with_max_size() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
-            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { height: stretch::style::Dimension::Points(100f32), ..Default::default() },
             max_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(80.0000),
+                height: stretch::style::Dimension::Points(80f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(20.0000),
-                    height: stretch::style::Dimension::Points(20.0000),
+                    width: stretch::style::Dimension::Points(20f32),
+                    height: stretch::style::Dimension::Points(20f32),
                     ..Default::default()
                 },
                 margin: stretch::geometry::Rect {
-                    top: stretch::style::Dimension::Points(100.0000),
+                    top: stretch::style::Dimension::Points(100f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -25,14 +25,12 @@ fn flex_shrink_by_outer_margin_with_max_size() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 20.0000);
-    assert_eq!(layout.size.height, 80.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].size.height, 0.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 100.0000);
+    assert_eq!(layout.size.width, 20f32);
+    assert_eq!(layout.size.height, 80f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].size.height, 0f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 100f32);
 }
diff --git a/tests/generated/flex_shrink_flex_grow_child_flex_shrink_other_child.rs b/tests/generated/flex_shrink_flex_grow_child_flex_shrink_other_child.rs
index 6cd4827cf..57a15dddf 100644
--- a/tests/generated/flex_shrink_flex_grow_child_flex_shrink_other_child.rs
+++ b/tests/generated/flex_shrink_flex_grow_child_flex_shrink_other_child.rs
@@ -3,27 +3,27 @@ fn flex_shrink_flex_grow_child_flex_shrink_other_child() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(500.0000),
-                height: stretch::style::Dimension::Points(500.0000),
+                width: stretch::style::Dimension::Points(500f32),
+                height: stretch::style::Dimension::Points(500f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 0.0000,
-                    flex_shrink: 1.0000,
+                    flex_grow: 0f32,
+                    flex_shrink: 1f32,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(500.0000),
-                        height: stretch::style::Dimension::Points(100.0000),
+                        width: stretch::style::Dimension::Points(500f32),
+                        height: stretch::style::Dimension::Points(100f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_grow: 1.0000,
-                    flex_shrink: 1.0000,
+                    flex_grow: 1f32,
+                    flex_shrink: 1f32,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(500.0000),
-                        height: stretch::style::Dimension::Points(100.0000),
+                        width: stretch::style::Dimension::Points(500f32),
+                        height: stretch::style::Dimension::Points(100f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -34,19 +34,16 @@ fn flex_shrink_flex_grow_child_flex_shrink_other_child() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 500.0000);
-    assert_eq!(layout.size.height, 500.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 250.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 250.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 250.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 500f32);
+    assert_eq!(layout.size.height, 500f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 250f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 250f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 250f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_shrink_flex_grow_row.rs b/tests/generated/flex_shrink_flex_grow_row.rs
index 19fc793ff..fa97630c4 100644
--- a/tests/generated/flex_shrink_flex_grow_row.rs
+++ b/tests/generated/flex_shrink_flex_grow_row.rs
@@ -3,27 +3,27 @@ fn flex_shrink_flex_grow_row() {
     let layout = stretch::compute(
         &stretch::style::Node {
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(500.0000),
-                height: stretch::style::Dimension::Points(500.0000),
+                width: stretch::style::Dimension::Points(500f32),
+                height: stretch::style::Dimension::Points(500f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
-                    flex_grow: 0.0000,
-                    flex_shrink: 1.0000,
+                    flex_grow: 0f32,
+                    flex_shrink: 1f32,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(500.0000),
-                        height: stretch::style::Dimension::Points(100.0000),
+                        width: stretch::style::Dimension::Points(500f32),
+                        height: stretch::style::Dimension::Points(100f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_grow: 0.0000,
-                    flex_shrink: 1.0000,
+                    flex_grow: 0f32,
+                    flex_shrink: 1f32,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(500.0000),
-                        height: stretch::style::Dimension::Points(100.0000),
+                        width: stretch::style::Dimension::Points(500f32),
+                        height: stretch::style::Dimension::Points(100f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -34,19 +34,16 @@ fn flex_shrink_flex_grow_row() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 500.0000);
-    assert_eq!(layout.size.height, 500.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 250.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 250.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 250.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 500f32);
+    assert_eq!(layout.size.height, 500f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 250f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 250f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 250f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_shrink_to_zero.rs b/tests/generated/flex_shrink_to_zero.rs
index 1049f92f3..5348de15c 100644
--- a/tests/generated/flex_shrink_to_zero.rs
+++ b/tests/generated/flex_shrink_to_zero.rs
@@ -2,31 +2,31 @@
 fn flex_shrink_to_zero() {
     let layout = stretch::compute(
         &stretch::style::Node {
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(75.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(75f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
-                    flex_shrink: 0.0000,
+                    flex_shrink: 0f32,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_shrink: 1.0000,
+                    flex_shrink: 1f32,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_shrink: 0.0000,
+                    flex_shrink: 0f32,
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
-                        height: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -37,24 +37,20 @@ fn flex_shrink_to_zero() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 75.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 0.0000);
-    assert_eq!(layout.children[1].size.height, 50.0000);
-    assert_eq!(layout.children[1].location.x, 50.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
-
-    assert_eq!(layout.children[2].size.width, 50.0000);
-    assert_eq!(layout.children[2].size.height, 50.0000);
-    assert_eq!(layout.children[2].location.x, 50.0000);
-    assert_eq!(layout.children[2].location.y, 0.0000);
+    assert_eq!(layout.size.width, 75f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 0f32);
+    assert_eq!(layout.children[1usize].size.height, 50f32);
+    assert_eq!(layout.children[1usize].location.x, 50f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
+    assert_eq!(layout.children[2usize].size.width, 50f32);
+    assert_eq!(layout.children[2usize].size.height, 50f32);
+    assert_eq!(layout.children[2usize].location.x, 50f32);
+    assert_eq!(layout.children[2usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_wrap_align_stretch_fits_one_row.rs b/tests/generated/flex_wrap_align_stretch_fits_one_row.rs
index aec7bdf71..78e7d936e 100644
--- a/tests/generated/flex_wrap_align_stretch_fits_one_row.rs
+++ b/tests/generated/flex_wrap_align_stretch_fits_one_row.rs
@@ -4,21 +4,21 @@ fn flex_wrap_align_stretch_fits_one_row() {
         &stretch::style::Node {
             flex_wrap: stretch::style::FlexWrap::Wrap,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(150.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(150f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(50.0000),
+                        width: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -29,19 +29,16 @@ fn flex_wrap_align_stretch_fits_one_row() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 150.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 50.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 50.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 50.0000);
-    assert_eq!(layout.children[1].location.y, 0.0000);
+    assert_eq!(layout.size.width, 150f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 50f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 50f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 50f32);
+    assert_eq!(layout.children[1usize].location.y, 0f32);
 }
diff --git a/tests/generated/flex_wrap_children_with_min_main_overriding_flex_basis.rs b/tests/generated/flex_wrap_children_with_min_main_overriding_flex_basis.rs
index 305173399..48ac40983 100644
--- a/tests/generated/flex_wrap_children_with_min_main_overriding_flex_basis.rs
+++ b/tests/generated/flex_wrap_children_with_min_main_overriding_flex_basis.rs
@@ -3,28 +3,28 @@ fn flex_wrap_children_with_min_main_overriding_flex_basis() {
     let layout = stretch::compute(
         &stretch::style::Node {
             flex_wrap: stretch::style::FlexWrap::Wrap,
-            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100.0000), ..Default::default() },
+            size: stretch::geometry::Size { width: stretch::style::Dimension::Points(100f32), ..Default::default() },
             children: vec![
                 stretch::style::Node {
-                    flex_basis: stretch::style::Dimension::Points(50.0000),
+                    flex_basis: stretch::style::Dimension::Points(50f32),
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(50.0000),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     min_size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(55.0000),
+                        width: stretch::style::Dimension::Points(55f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
-                    flex_basis: stretch::style::Dimension::Points(50.0000),
+                    flex_basis: stretch::style::Dimension::Points(50f32),
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(50.0000),
+                        height: stretch::style::Dimension::Points(50f32),
                         ..Default::default()
                     },
                     min_size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(55.0000),
+                        width: stretch::style::Dimension::Points(55f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -35,19 +35,16 @@ fn flex_wrap_children_with_min_main_overriding_flex_basis() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 55.0000);
-    assert_eq!(layout.children[0].size.height, 50.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 55.0000);
-    assert_eq!(layout.children[1].size.height, 50.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 50.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 55f32);
+    assert_eq!(layout.children[0usize].size.height, 50f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 55f32);
+    assert_eq!(layout.children[1usize].size.height, 50f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 50f32);
 }
diff --git a/tests/generated/flex_wrap_wrap_to_child_height.rs b/tests/generated/flex_wrap_wrap_to_child_height.rs
index 79cfe3141..669c03b1d 100644
--- a/tests/generated/flex_wrap_wrap_to_child_height.rs
+++ b/tests/generated/flex_wrap_wrap_to_child_height.rs
@@ -10,13 +10,13 @@ fn flex_wrap_wrap_to_child_height() {
                     children: vec![stretch::style::Node {
                         flex_direction: stretch::style::FlexDirection::Column,
                         size: stretch::geometry::Size {
-                            width: stretch::style::Dimension::Points(100.0000),
+                            width: stretch::style::Dimension::Points(100f32),
                             ..Default::default()
                         },
                         children: vec![stretch::style::Node {
                             size: stretch::geometry::Size {
-                                width: stretch::style::Dimension::Points(100.0000),
-                                height: stretch::style::Dimension::Points(100.0000),
+                                width: stretch::style::Dimension::Points(100f32),
+                                height: stretch::style::Dimension::Points(100f32),
                                 ..Default::default()
                             },
                             ..Default::default()
@@ -27,8 +27,8 @@ fn flex_wrap_wrap_to_child_height() {
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(100.0000),
-                        height: stretch::style::Dimension::Points(100.0000),
+                        width: stretch::style::Dimension::Points(100f32),
+                        height: stretch::style::Dimension::Points(100f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -39,29 +39,24 @@ fn flex_wrap_wrap_to_child_height() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 200.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[0].children[0].children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].children[0].children[0].size.height, 100.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].children[0].children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 100.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 100.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 200f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].size.height, 100f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].children[0usize].children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 100f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 100f32);
 }
diff --git a/tests/generated/justify_content_column_center.rs b/tests/generated/justify_content_column_center.rs
index 0954314ea..afd453893 100644
--- a/tests/generated/justify_content_column_center.rs
+++ b/tests/generated/justify_content_column_center.rs
@@ -5,28 +5,28 @@ fn justify_content_column_center() {
             flex_direction: stretch::style::FlexDirection::Column,
             justify_content: stretch::style::JustifyContent::Center,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -37,24 +37,20 @@ fn justify_content_column_center() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 35.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 10.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 45.0000);
-
-    assert_eq!(layout.children[2].size.width, 100.0000);
-    assert_eq!(layout.children[2].size.height, 10.0000);
-    assert_eq!(layout.children[2].location.x, 0.0000);
-    assert_eq!(layout.children[2].location.y, 55.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 35f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 45f32);
+    assert_eq!(layout.children[2usize].size.width, 100f32);
+    assert_eq!(layout.children[2usize].size.height, 10f32);
+    assert_eq!(layout.children[2usize].location.x, 0f32);
+    assert_eq!(layout.children[2usize].location.y, 55f32);
 }
diff --git a/tests/generated/justify_content_column_flex_end.rs b/tests/generated/justify_content_column_flex_end.rs
index 3b8bcc414..7f9447c3e 100644
--- a/tests/generated/justify_content_column_flex_end.rs
+++ b/tests/generated/justify_content_column_flex_end.rs
@@ -5,28 +5,28 @@ fn justify_content_column_flex_end() {
             flex_direction: stretch::style::FlexDirection::Column,
             justify_content: stretch::style::JustifyContent::FlexEnd,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -37,24 +37,20 @@ fn justify_content_column_flex_end() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 70.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 10.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 80.0000);
-
-    assert_eq!(layout.children[2].size.width, 100.0000);
-    assert_eq!(layout.children[2].size.height, 10.0000);
-    assert_eq!(layout.children[2].location.x, 0.0000);
-    assert_eq!(layout.children[2].location.y, 90.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 70f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 80f32);
+    assert_eq!(layout.children[2usize].size.width, 100f32);
+    assert_eq!(layout.children[2usize].size.height, 10f32);
+    assert_eq!(layout.children[2usize].location.x, 0f32);
+    assert_eq!(layout.children[2usize].location.y, 90f32);
 }
diff --git a/tests/generated/justify_content_column_flex_start.rs b/tests/generated/justify_content_column_flex_start.rs
index 0403f67b1..e004119c8 100644
--- a/tests/generated/justify_content_column_flex_start.rs
+++ b/tests/generated/justify_content_column_flex_start.rs
@@ -4,28 +4,28 @@ fn justify_content_column_flex_start() {
         &stretch::style::Node {
             flex_direction: stretch::style::FlexDirection::Column,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -36,24 +36,20 @@ fn justify_content_column_flex_start() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 10.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 10.0000);
-
-    assert_eq!(layout.children[2].size.width, 100.0000);
-    assert_eq!(layout.children[2].size.height, 10.0000);
-    assert_eq!(layout.children[2].location.x, 0.0000);
-    assert_eq!(layout.children[2].location.y, 20.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 0f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 10f32);
+    assert_eq!(layout.children[2usize].size.width, 100f32);
+    assert_eq!(layout.children[2usize].size.height, 10f32);
+    assert_eq!(layout.children[2usize].location.x, 0f32);
+    assert_eq!(layout.children[2usize].location.y, 20f32);
 }
diff --git a/tests/generated/justify_content_column_min_height_and_margin_bottom.rs b/tests/generated/justify_content_column_min_height_and_margin_bottom.rs
index 3dbb02bd4..c9782d37c 100644
--- a/tests/generated/justify_content_column_min_height_and_margin_bottom.rs
+++ b/tests/generated/justify_content_column_min_height_and_margin_bottom.rs
@@ -5,17 +5,17 @@ fn justify_content_column_min_height_and_margin_bottom() {
             flex_direction: stretch::style::FlexDirection::Column,
             justify_content: stretch::style::JustifyContent::Center,
             min_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(50.0000),
+                height: stretch::style::Dimension::Points(50f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(20.0000),
-                    height: stretch::style::Dimension::Points(20.0000),
+                    width: stretch::style::Dimension::Points(20f32),
+                    height: stretch::style::Dimension::Points(20f32),
                     ..Default::default()
                 },
                 margin: stretch::geometry::Rect {
-                    bottom: stretch::style::Dimension::Points(10.0000),
+                    bottom: stretch::style::Dimension::Points(10f32),
                     ..Default::default()
                 },
                 ..Default::default()
@@ -25,14 +25,12 @@ fn justify_content_column_min_height_and_margin_bottom() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 20.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 10.0000);
+    assert_eq!(layout.size.width, 20f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 10f32);
 }
diff --git a/tests/generated/justify_content_column_min_height_and_margin_top.rs b/tests/generated/justify_content_column_min_height_and_margin_top.rs
index 6967a8c42..e3bdc133a 100644
--- a/tests/generated/justify_content_column_min_height_and_margin_top.rs
+++ b/tests/generated/justify_content_column_min_height_and_margin_top.rs
@@ -5,19 +5,16 @@ fn justify_content_column_min_height_and_margin_top() {
             flex_direction: stretch::style::FlexDirection::Column,
             justify_content: stretch::style::JustifyContent::Center,
             min_size: stretch::geometry::Size {
-                height: stretch::style::Dimension::Points(50.0000),
+                height: stretch::style::Dimension::Points(50f32),
                 ..Default::default()
             },
             children: vec![stretch::style::Node {
                 size: stretch::geometry::Size {
-                    width: stretch::style::Dimension::Points(20.0000),
-                    height: stretch::style::Dimension::Points(20.0000),
-                    ..Default::default()
-                },
-                margin: stretch::geometry::Rect {
-                    top: stretch::style::Dimension::Points(10.0000),
+                    width: stretch::style::Dimension::Points(20f32),
+                    height: stretch::style::Dimension::Points(20f32),
                     ..Default::default()
                 },
+                margin: stretch::geometry::Rect { top: stretch::style::Dimension::Points(10f32), ..Default::default() },
                 ..Default::default()
             }],
             ..Default::default()
@@ -25,14 +22,12 @@ fn justify_content_column_min_height_and_margin_top() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 20.0000);
-    assert_eq!(layout.size.height, 50.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 20.0000);
-    assert_eq!(layout.children[0].size.height, 20.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 20.0000);
+    assert_eq!(layout.size.width, 20f32);
+    assert_eq!(layout.size.height, 50f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 20f32);
+    assert_eq!(layout.children[0usize].size.height, 20f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 20f32);
 }
diff --git a/tests/generated/justify_content_column_space_around.rs b/tests/generated/justify_content_column_space_around.rs
index e1f9687a7..637b3e142 100644
--- a/tests/generated/justify_content_column_space_around.rs
+++ b/tests/generated/justify_content_column_space_around.rs
@@ -5,28 +5,28 @@ fn justify_content_column_space_around() {
             flex_direction: stretch::style::FlexDirection::Column,
             justify_content: stretch::style::JustifyContent::SpaceAround,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -37,24 +37,20 @@ fn justify_content_column_space_around() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 12.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 10.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 45.0000);
-
-    assert_eq!(layout.children[2].size.width, 100.0000);
-    assert_eq!(layout.children[2].size.height, 10.0000);
-    assert_eq!(layout.children[2].location.x, 0.0000);
-    assert_eq!(layout.children[2].location.y, 78.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    assert_eq!(layout.location.y, 0f32);
+    assert_eq!(layout.children[0usize].size.width, 100f32);
+    assert_eq!(layout.children[0usize].size.height, 10f32);
+    assert_eq!(layout.children[0usize].location.x, 0f32);
+    assert_eq!(layout.children[0usize].location.y, 12f32);
+    assert_eq!(layout.children[1usize].size.width, 100f32);
+    assert_eq!(layout.children[1usize].size.height, 10f32);
+    assert_eq!(layout.children[1usize].location.x, 0f32);
+    assert_eq!(layout.children[1usize].location.y, 45f32);
+    assert_eq!(layout.children[2usize].size.width, 100f32);
+    assert_eq!(layout.children[2usize].size.height, 10f32);
+    assert_eq!(layout.children[2usize].location.x, 0f32);
+    assert_eq!(layout.children[2usize].location.y, 78f32);
 }
diff --git a/tests/generated/justify_content_column_space_between.rs b/tests/generated/justify_content_column_space_between.rs
index d5f2acfb4..bae6844b2 100644
--- a/tests/generated/justify_content_column_space_between.rs
+++ b/tests/generated/justify_content_column_space_between.rs
@@ -5,28 +5,28 @@ fn justify_content_column_space_between() {
             flex_direction: stretch::style::FlexDirection::Column,
             justify_content: stretch::style::JustifyContent::SpaceBetween,
             size: stretch::geometry::Size {
-                width: stretch::style::Dimension::Points(100.0000),
-                height: stretch::style::Dimension::Points(100.0000),
+                width: stretch::style::Dimension::Points(100f32),
+                height: stretch::style::Dimension::Points(100f32),
                 ..Default::default()
             },
             children: vec![
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
                 },
                 stretch::style::Node {
                     size: stretch::geometry::Size {
-                        height: stretch::style::Dimension::Points(10.0000),
+                        height: stretch::style::Dimension::Points(10f32),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -37,24 +37,20 @@ fn justify_content_column_space_between() {
         stretch::geometry::Size::undefined(),
     )
     .unwrap();
-
-    assert_eq!(layout.size.width, 100.0000);
-    assert_eq!(layout.size.height, 100.0000);
-    assert_eq!(layout.location.x, 0.0000);
-    assert_eq!(layout.location.y, 0.0000);
-
-    assert_eq!(layout.children[0].size.width, 100.0000);
-    assert_eq!(layout.children[0].size.height, 10.0000);
-    assert_eq!(layout.children[0].location.x, 0.0000);
-    assert_eq!(layout.children[0].location.y, 0.0000);
-
-    assert_eq!(layout.children[1].size.width, 100.0000);
-    assert_eq!(layout.children[1].size.height, 10.0000);
-    assert_eq!(layout.children[1].location.x, 0.0000);
-    assert_eq!(layout.children[1].location.y, 45.0000);
-
-    assert_eq!(layout.children[2].size.width, 100.0000);
-    assert_eq!(layout.children[2].size.height, 10.0000);
-    assert_eq!(layout.children[2].location.x, 0.0000);
-    assert_eq!(layout.children[2].location.y, 90.0000);
+    assert_eq!(layout.size.width, 100f32);
+    assert_eq!(layout.size.height, 100f32);
+    assert_eq!(layout.location.x, 0f32);
+    as