diff --git a/java/tests/com/facebook/yoga/YogaNodeStylePropertiesTest.java b/java/tests/com/facebook/yoga/YogaNodeStylePropertiesTest.java
new file mode 100644
index 00000000..8efcdd13
--- /dev/null
+++ b/java/tests/com/facebook/yoga/YogaNodeStylePropertiesTest.java
@@ -0,0 +1,983 @@
+/*
+ *  Copyright (c) 2014-present, Facebook, Inc.
+ *
+ *  This source code is licensed under the MIT license found in the LICENSE
+ *  file in the root directory of this source tree.
+ *
+ */
+package com.facebook.yoga;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class YogaNodeStylePropertiesTest {
+
+  private static final float UNDEFINED = YogaValue.UNDEFINED.value;
+
+  @Test
+  public void testDirectionDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(node.getStyleDirection(), YogaDirection.INHERIT);
+    assertEquals(node.getLayoutDirection(), YogaDirection.INHERIT);
+  }
+
+  @Test
+  public void testDirectionAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setDirection(YogaDirection.LTR);
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(YogaDirection.LTR, node.getStyleDirection());
+    assertEquals(YogaDirection.LTR, node.getLayoutDirection());
+  }
+
+  @Test
+  public void testDirectionAffectsLayout() {
+    final YogaNode node =
+        style().direction(YogaDirection.RTL).width(200).children(style().widthPercent(40)).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(120, node.getChildAt(0).getLayoutX(), 0);
+  }
+
+  @Test
+  public void testFlexDirectionDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaFlexDirection.COLUMN, node.getFlexDirection());
+  }
+
+  @Test
+  public void testFlexDirectionAssignment() {
+    final YogaNode node = style().flexDirection(YogaFlexDirection.COLUMN_REVERSE).node();
+
+    assertEquals(YogaFlexDirection.COLUMN_REVERSE, node.getFlexDirection());
+  }
+
+  @Test
+  public void testFlexDirectionAffectsLayout() {
+    final YogaNode node =
+        style()
+            .flexDirection(YogaFlexDirection.ROW_REVERSE)
+            .width(200)
+            .children(style().widthPercent(40))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(120, node.getChildAt(0).getLayoutX(), 0);
+  }
+
+  @Test
+  public void testJustifyContentDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaJustify.FLEX_START, node.getJustifyContent());
+  }
+
+  @Test
+  public void testJustifyContentAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setJustifyContent(YogaJustify.SPACE_EVENLY);
+
+    assertEquals(YogaJustify.SPACE_EVENLY, node.getJustifyContent());
+  }
+
+  @Test
+  public void testJustifyContentAffectsLayout() {
+    final YogaNode node =
+        style()
+            .justifyContent(YogaJustify.CENTER)
+            .height(200)
+            .children(style().heightPercent(40))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(60, node.getChildAt(0).getLayoutY(), 0);
+  }
+
+  @Test
+  public void testAlignItemsDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaAlign.STRETCH, node.getAlignItems());
+  }
+
+  @Test
+  public void testAlignItemsAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setAlignItems(YogaAlign.SPACE_AROUND);
+
+    assertEquals(YogaAlign.SPACE_AROUND, node.getAlignItems());
+  }
+
+  @Test
+  public void testAlignItemsAffectsLayout() {
+    final YogaNode node =
+        style().alignItems(YogaAlign.CENTER).height(200).children(style().widthPercent(40)).node();
+    node.calculateLayout(200, UNDEFINED);
+
+    assertEquals(60, node.getChildAt(0).getLayoutX(), 0);
+  }
+
+  @Test
+  public void testAlignSelfDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaAlign.AUTO, node.getAlignSelf());
+  }
+
+  @Test
+  public void testAlignSelfAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setAlignSelf(YogaAlign.FLEX_END);
+
+    assertEquals(YogaAlign.FLEX_END, node.getAlignSelf());
+  }
+
+  @Test
+  public void testAlignSelfAffectsLayout() {
+    final YogaNode node =
+        style().height(200).children(style().alignSelf(YogaAlign.CENTER).widthPercent(40)).node();
+    node.calculateLayout(200, UNDEFINED);
+
+    assertEquals(60, node.getChildAt(0).getLayoutX(), 0);
+  }
+
+  @Test
+  public void testAlignContentDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaAlign.FLEX_START, node.getAlignContent());
+  }
+
+  @Test
+  public void testAlignContentAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setAlignContent(YogaAlign.BASELINE);
+
+    assertEquals(YogaAlign.BASELINE, node.getAlignContent());
+  }
+
+  @Test
+  public void testAlignContentAffectsLayout() {
+    final YogaNode node =
+        style()
+            .alignContent(YogaAlign.SPACE_AROUND)
+            .flexWrap(YogaWrap.WRAP)
+            .height(200)
+            .width(200)
+            .children(
+                style().widthPercent(20).heightPercent(60),
+                style().widthPercent(20).heightPercent(60))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(30, node.getChildAt(0).getLayoutX(), 0);
+  }
+
+  @Test
+  public void testPositionTypeDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaPositionType.RELATIVE, node.getPositionType());
+  }
+
+  @Test
+  public void testPositionTypeAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setPositionType(YogaPositionType.ABSOLUTE);
+
+    assertEquals(YogaPositionType.ABSOLUTE, node.getPositionType());
+  }
+
+  @Test
+  public void testPositionTypeAffectsLayout() {
+    final YogaNode node =
+        style()
+            .height(200)
+            .children(
+                style().height(100), style().height(100).positionType(YogaPositionType.ABSOLUTE))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(0, node.getChildAt(1).getLayoutY(), 0);
+  }
+
+  @Test
+  public void testWrapAffectsLayout() {
+    final YogaNode node =
+        style()
+            .width(200)
+            .height(200)
+            .flexWrap(YogaWrap.WRAP_REVERSE)
+            .children(style().width(10).heightPercent(60), style().heightPercent(60))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(190, node.getChildAt(0).getLayoutX(), 0);
+  }
+
+  @Test
+  public void testOverflowDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaOverflow.VISIBLE, node.getOverflow());
+  }
+
+  @Test
+  public void testOverflowAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setOverflow(YogaOverflow.SCROLL);
+
+    assertEquals(YogaOverflow.SCROLL, node.getOverflow());
+  }
+
+  // TODO add testOverflowAffectsLayout()
+
+  @Test
+  public void testDisplayDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaDisplay.FLEX, node.getDisplay());
+  }
+
+  @Test
+  public void testDisplayAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setDisplay(YogaDisplay.NONE);
+
+    assertEquals(YogaDisplay.NONE, node.getDisplay());
+  }
+
+  @Test
+  public void testDisplayAffectsLayout() {
+    final YogaNode node =
+        style().children(style().flexGrow(1).display(YogaDisplay.NONE), style().flexGrow(1)).node();
+    node.calculateLayout(200, 200);
+
+    assertEquals(200, node.getChildAt(1).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testFlexAffectsLayoutGrowing() {
+    final YogaNode node = style().height(200).children(style().height(100).flex(1.25f)).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(200, node.getChildAt(0).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testFlexAffectsLayoutShrinking() {
+    final YogaNode node = style().height(200).children(style().height(300).flex(1.25f)).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(200, node.getChildAt(0).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testFlexGrowDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(0, node.getFlexGrow(), 0);
+  }
+
+  @Test
+  public void testFlexGrowAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setFlexGrow(2.5f);
+
+    assertEquals(2.5f, node.getFlexGrow(), 0);
+  }
+
+  @Test
+  public void testFlexGrowAffectsLayout() {
+    final YogaNode node =
+        style().height(200).children(style().height(50).flexGrow(1), style().height(50)).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(150, node.getChildAt(0).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testFlexShrinkDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(0, node.getFlexShrink(), 0);
+  }
+
+  @Test
+  public void testFlexShrinkAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setFlexShrink(2.5f);
+
+    assertEquals(2.5f, node.getFlexShrink(), 0);
+  }
+
+  @Test
+  public void testFlexShrinkAffectsLayout() {
+    final YogaNode node =
+        style().height(200).children(style().height(150).flexShrink(1), style().height(150)).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(50, node.getChildAt(0).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testFlexBasisDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaValue.AUTO, node.getFlexBasis());
+  }
+
+  @Test
+  public void testFlexBasisAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setFlexBasis(50);
+    assertEquals(new YogaValue(50, YogaUnit.POINT), node.getFlexBasis());
+
+    node.setFlexBasisPercent(20);
+    assertEquals(new YogaValue(20, YogaUnit.PERCENT), node.getFlexBasis());
+
+    node.setFlexBasisAuto();
+    assertEquals(YogaValue.AUTO, node.getFlexBasis());
+  }
+
+  @Test
+  public void testFlexBasisAffectsLayout() {
+    final YogaNode node =
+        style()
+            .height(200)
+            .children(style().flexBasis(150).flexShrink(1), style().flexBasis(150).flexShrink(1))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(100, node.getChildAt(0).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testFlexBasisPercentAffectsLayout() {
+    final YogaNode node =
+        style()
+            .height(200)
+            .children(style().flexBasisPercent(60), style().flexBasisPercent(40))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(80, node.getChildAt(1).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testMarginDefault() {
+    final YogaNode node = new YogaNode();
+    for (YogaEdge edge : YogaEdge.values()) {
+      assertEquals(YogaValue.UNDEFINED, node.getMargin(edge));
+    }
+  }
+
+  @Test
+  public void testMarginAssignment() {
+    final YogaNode node = new YogaNode();
+    for (YogaEdge edge : YogaEdge.values()) {
+      node.setMargin(edge, 25);
+      assertEquals(new YogaValue(25, YogaUnit.POINT), node.getMargin(edge));
+
+      node.setMarginPercent(edge, 5);
+      assertEquals(new YogaValue(5, YogaUnit.PERCENT), node.getMargin(edge));
+
+      node.setMarginAuto(edge);
+      assertEquals(YogaValue.AUTO, node.getMargin(edge));
+    }
+  }
+
+  @Test
+  public void testMarginPointAffectsLayout() {
+    final YogaNode node = style().margin(YogaEdge.TOP, 42).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(42, node.getLayoutY(), 0);
+  }
+
+  @Test
+  public void testMarginPercentAffectsLayout() {
+    final YogaNode node =
+        style().height(200).children(style().flexGrow(1).marginPercent(YogaEdge.TOP, 20)).node();
+    node.calculateLayout(200, 200);
+
+    assertEquals(40, node.getChildAt(0).getLayoutY(), 0);
+  }
+
+  @Test
+  public void testMarginAutoAffectsLayout() {
+    final YogaNode node =
+        style()
+            .width(200)
+            .flexDirection(YogaFlexDirection.ROW)
+            .children(style().marginAuto(YogaEdge.LEFT).marginAuto(YogaEdge.RIGHT).width(100))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(50, node.getChildAt(0).getLayoutX(), 0);
+  }
+
+  @Test
+  public void testPaddingDefault() {
+    final YogaNode node = new YogaNode();
+    for (YogaEdge edge : YogaEdge.values()) {
+      assertEquals(YogaValue.UNDEFINED, node.getPadding(edge));
+    }
+  }
+
+  @Test
+  public void testPaddingAssignment() {
+    final YogaNode node = new YogaNode();
+    for (YogaEdge edge : YogaEdge.values()) {
+      node.setPadding(edge, 25);
+      assertEquals(new YogaValue(25, YogaUnit.POINT), node.getPadding(edge));
+
+      node.setPaddingPercent(edge, 5);
+      assertEquals(new YogaValue(5, YogaUnit.PERCENT), node.getPadding(edge));
+    }
+  }
+
+  @Test
+  public void testPaddingPointAffectsLayout() {
+    final YogaNode node = style().padding(YogaEdge.TOP, 42).children(style()).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(42, node.getChildAt(0).getLayoutY(), 0);
+  }
+
+  @Test
+  public void testPaddingPercentAffectsLayout() {
+    final YogaNode node =
+        style().height(200).paddingPercent(YogaEdge.TOP, 20).children(style().flexGrow(1)).node();
+    node.calculateLayout(200, 200);
+
+    assertEquals(40, node.getChildAt(0).getLayoutY(), 0);
+  }
+
+  @Test
+  public void testBorderDefault() {
+    final YogaNode node = new YogaNode();
+    for (YogaEdge edge : YogaEdge.values()) {
+      assertEquals(UNDEFINED, node.getBorder(edge), 0);
+    }
+  }
+
+  @Test
+  public void testBorderAssignment() {
+    final YogaNode node = new YogaNode();
+    for (YogaEdge edge : YogaEdge.values()) {
+      node.setBorder(edge, 2.5f);
+      assertEquals(2.5f, node.getBorder(edge), 0);
+    }
+  }
+
+  @Test
+  public void testBorderAffectsLayout() {
+    final YogaNode node = style().border(YogaEdge.TOP, 42).children(style()).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(42, node.getChildAt(0).getLayoutY(), 0);
+  }
+
+  @Test
+  public void testPositionDefault() {
+    final YogaNode node = new YogaNode();
+    for (YogaEdge edge : YogaEdge.values()) {
+      assertEquals(YogaValue.UNDEFINED, node.getPosition(edge));
+    }
+  }
+
+  @Test
+  public void testPositionAssignment() {
+    final YogaNode node = new YogaNode();
+    for (YogaEdge edge : YogaEdge.values()) {
+      node.setPosition(edge, 25);
+      assertEquals(new YogaValue(25, YogaUnit.POINT), node.getPosition(edge));
+
+      node.setPositionPercent(edge, 5);
+      assertEquals(new YogaValue(5, YogaUnit.PERCENT), node.getPosition(edge));
+    }
+  }
+
+  @Test
+  public void testPositionAffectsLayout() {
+    final YogaNode node =
+        style()
+            .height(100)
+            .children(
+                style()
+                    .positionType(YogaPositionType.ABSOLUTE)
+                    .position(YogaEdge.TOP, 11)
+                    .position(YogaEdge.BOTTOM, 22))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(67, node.getChildAt(0).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testPositionPercentAffectsLayout() {
+    final YogaNode node =
+        style()
+            .width(100)
+            .children(
+                style()
+                    .positionType(YogaPositionType.ABSOLUTE)
+                    .positionPercent(YogaEdge.LEFT, 11)
+                    .positionPercent(YogaEdge.RIGHT, 22))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(67, node.getChildAt(0).getLayoutWidth(), 0);
+  }
+
+  @Test
+  public void testWidthDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaValue.AUTO, node.getWidth());
+  }
+
+  @Test
+  public void testWidthAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setWidth(123);
+    assertEquals(new YogaValue(123, YogaUnit.POINT), node.getWidth());
+
+    node.setWidthPercent(45);
+    assertEquals(new YogaValue(45, YogaUnit.PERCENT), node.getWidth());
+  }
+
+  @Test
+  public void testWidthAffectsLayout() {
+    final YogaNode node = style().width(123).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(123, node.getLayoutWidth(), 0);
+  }
+
+  @Test
+  public void testWidthPercentAffectsLayout() {
+    final YogaNode node = style().widthPercent(75).node();
+    node.calculateLayout(200, UNDEFINED);
+
+    assertEquals(150, node.getLayoutWidth(), 0);
+  }
+
+  // TODO: testWidthAutoAffectsLayout
+
+  @Test
+  public void testHeightDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaValue.AUTO, node.getHeight());
+  }
+
+  @Test
+  public void testHeightAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setHeight(123);
+    assertEquals(new YogaValue(123, YogaUnit.POINT), node.getHeight());
+
+    node.setHeightPercent(45);
+    assertEquals(new YogaValue(45, YogaUnit.PERCENT), node.getHeight());
+  }
+
+  @Test
+  public void testHeightAffectsLayout() {
+    final YogaNode node = style().height(123).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(123, node.getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testHeightPercentAffectsLayout() {
+    final YogaNode node = style().heightPercent(75).node();
+    node.calculateLayout(UNDEFINED, 200);
+
+    assertEquals(150, node.getLayoutHeight(), 0);
+  }
+
+  // TODO: testHeightAutoAffectsLayout
+
+  @Test
+  public void testMinWidthDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaValue.UNDEFINED, node.getMinWidth());
+  }
+
+  @Test
+  public void testMinWidthAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setMinWidth(123);
+    assertEquals(new YogaValue(123, YogaUnit.POINT), node.getMinWidth());
+
+    node.setMinWidthPercent(45);
+    assertEquals(new YogaValue(45, YogaUnit.PERCENT), node.getMinWidth());
+  }
+
+  @Test
+  public void testMinWidthAffectsLayout() {
+    final YogaNode node = style().minWidth(123).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(123, node.getLayoutWidth(), 0);
+  }
+
+  @Test
+  public void testMinWidthPercentAffectsLayout() {
+    final YogaNode node = style().minWidthPercent(120).node();
+    node.calculateLayout(200, UNDEFINED);
+
+    assertEquals(240, node.getLayoutWidth(), 0);
+  }
+
+  @Test
+  public void testMinHeightDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaValue.UNDEFINED, node.getMinHeight());
+  }
+
+  @Test
+  public void testMinHeightAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setMinHeight(123);
+    assertEquals(new YogaValue(123, YogaUnit.POINT), node.getMinHeight());
+
+    node.setMinHeightPercent(45);
+    assertEquals(new YogaValue(45, YogaUnit.PERCENT), node.getMinHeight());
+  }
+
+  @Test
+  public void testMinHeightAffectsLayout() {
+    final YogaNode node = style().minHeight(123).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(123, node.getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testMinHeightPercentAffectsLayout() {
+    final YogaNode node = style().minHeightPercent(120).node();
+    node.calculateLayout(UNDEFINED, 200);
+
+    assertEquals(240, node.getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testMaxWidthDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaValue.UNDEFINED, node.getMaxWidth());
+  }
+
+  @Test
+  public void testMaxWidthAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setMaxWidth(123);
+    assertEquals(new YogaValue(123, YogaUnit.POINT), node.getMaxWidth());
+
+    node.setMaxWidthPercent(45);
+    assertEquals(new YogaValue(45, YogaUnit.PERCENT), node.getMaxWidth());
+  }
+
+  @Test
+  public void testMaxWidthAffectsLayout() {
+    final YogaNode node = style().width(200).children(style().maxWidth(123)).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(123, node.getChildAt(0).getLayoutWidth(), 0);
+  }
+
+  @Test
+  public void testMaxWidthPercentAffectsLayout() {
+    final YogaNode node = style().width(200).children(style().maxWidthPercent(80)).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(160, node.getChildAt(0).getLayoutWidth(), 0);
+  }
+
+  @Test
+  public void testMaxHeightDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(YogaValue.UNDEFINED, node.getMaxHeight());
+  }
+
+  @Test
+  public void testMaxHeightAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setMaxHeight(123);
+    assertEquals(new YogaValue(123, YogaUnit.POINT), node.getMaxHeight());
+
+    node.setMaxHeightPercent(45);
+    assertEquals(new YogaValue(45, YogaUnit.PERCENT), node.getMaxHeight());
+  }
+
+  @Test
+  public void testMaxHeightAffectsLayout() {
+    final YogaNode node =
+        style()
+            .height(200)
+            .flexDirection(YogaFlexDirection.ROW)
+            .children(style().maxHeight(123))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(123, node.getChildAt(0).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testMaxHeightPercentAffectsLayout() {
+    final YogaNode node =
+        style()
+            .flexDirection(YogaFlexDirection.ROW)
+            .height(200)
+            .children(style().maxHeightPercent(80))
+            .node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(160, node.getChildAt(0).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void testAspectRatioDefault() {
+    final YogaNode node = new YogaNode();
+
+    assertEquals(UNDEFINED, node.getAspectRatio(), 0);
+  }
+
+  @Test
+  public void testAspectRatioAssignment() {
+    final YogaNode node = new YogaNode();
+    node.setAspectRatio(2.75f);
+
+    assertEquals(2.75f, node.getAspectRatio(), 0);
+  }
+
+  @Test
+  public void aspectRatioAffectsLayoutWithGivenWidth() {
+    final YogaNode node = style().children(style().width(300).aspectRatio(1.5f)).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(200, node.getChildAt(0).getLayoutHeight(), 0);
+  }
+
+  @Test
+  public void aspectRatioAffectsLayoutWithGivenHeight() {
+    final YogaNode node = style().children(style().height(300).aspectRatio(1.5f)).node();
+    node.calculateLayout(UNDEFINED, UNDEFINED);
+
+    assertEquals(450, node.getChildAt(0).getLayoutWidth(), 0);
+  }
+
+  private static StyledNode style() {
+    return new StyledNode();
+  }
+
+  private static class StyledNode {
+
+    private YogaNode mNode = new YogaNode();
+
+    YogaNode node() {
+      return mNode;
+    }
+
+    StyledNode children(StyledNode... children) {
+      for (int i = mNode.getChildCount(); --i >= 0; ) {
+        mNode.removeChildAt(i);
+      }
+      for (int i = 0; i < children.length; i++) {
+        mNode.addChildAt(children[i].node(), i);
+      }
+      return this;
+    }
+
+    StyledNode direction(YogaDirection direction) {
+      mNode.setDirection(direction);
+      return this;
+    }
+
+    StyledNode width(float width) {
+      mNode.setWidth(width);
+      return this;
+    }
+
+    StyledNode widthPercent(float width) {
+      mNode.setWidthPercent(width);
+      return this;
+    }
+
+    StyledNode flexDirection(YogaFlexDirection direction) {
+      mNode.setFlexDirection(direction);
+      return this;
+    }
+
+    StyledNode justifyContent(YogaJustify justify) {
+      mNode.setJustifyContent(justify);
+      return this;
+    }
+
+    StyledNode height(float height) {
+      mNode.setHeight(height);
+      return this;
+    }
+
+    StyledNode heightPercent(float height) {
+      mNode.setHeightPercent(height);
+      return this;
+    }
+
+    StyledNode alignItems(YogaAlign align) {
+      mNode.setAlignItems(align);
+      return this;
+    }
+
+    StyledNode alignSelf(YogaAlign align) {
+      mNode.setAlignSelf(align);
+      return this;
+    }
+
+    StyledNode alignContent(YogaAlign align) {
+      mNode.setAlignContent(align);
+      return this;
+    }
+
+    StyledNode flexWrap(YogaWrap wrap) {
+      mNode.setWrap(wrap);
+      return this;
+    }
+
+    StyledNode positionType(YogaPositionType positionType) {
+      mNode.setPositionType(positionType);
+      return this;
+    }
+
+    StyledNode overflow(YogaOverflow overflow) {
+      mNode.setOverflow(overflow);
+      return this;
+    }
+
+    StyledNode flexShrink(float flexShrink) {
+      mNode.setFlexShrink(flexShrink);
+      return this;
+    }
+
+    StyledNode display(YogaDisplay display) {
+      mNode.setDisplay(display);
+      return this;
+    }
+
+    StyledNode flexGrow(float flexGrow) {
+      mNode.setFlexGrow(flexGrow);
+      return this;
+    }
+
+    StyledNode flex(float flex) {
+      mNode.setFlex(flex);
+      return this;
+    }
+
+    StyledNode flexBasis(float flexBasis) {
+      mNode.setFlexBasis(flexBasis);
+      return this;
+    }
+
+    StyledNode flexBasisPercent(float flexBasis) {
+      mNode.setFlexBasisPercent(flexBasis);
+      return this;
+    }
+
+    StyledNode margin(YogaEdge edge, float margin) {
+      mNode.setMargin(edge, margin);
+      return this;
+    }
+
+    StyledNode marginPercent(YogaEdge edge, float margin) {
+      mNode.setMarginPercent(edge, margin);
+      return this;
+    }
+
+    StyledNode marginAuto(YogaEdge edge) {
+      mNode.setMarginAuto(edge);
+      return this;
+    }
+
+    StyledNode padding(YogaEdge edge, float padding) {
+      mNode.setPadding(edge, padding);
+      return this;
+    }
+
+    StyledNode paddingPercent(YogaEdge edge, float padding) {
+      mNode.setPaddingPercent(edge, padding);
+      return this;
+    }
+
+    StyledNode border(YogaEdge edge, float border) {
+      mNode.setBorder(edge, border);
+      return this;
+    }
+
+    StyledNode position(YogaEdge edge, float position) {
+      mNode.setPosition(edge, position);
+      return this;
+    }
+
+    StyledNode positionPercent(YogaEdge edge, float position) {
+      mNode.setPositionPercent(edge, position);
+      return this;
+    }
+
+    StyledNode minWidth(float minWidth) {
+      mNode.setMinWidth(minWidth);
+      return this;
+    }
+
+    StyledNode minWidthPercent(float minWidth) {
+      mNode.setMinWidthPercent(minWidth);
+      return this;
+    }
+
+    StyledNode minHeight(float minHeight) {
+      mNode.setMinHeight(minHeight);
+      return this;
+    }
+
+    StyledNode minHeightPercent(float minHeight) {
+      mNode.setMinHeightPercent(minHeight);
+      return this;
+    }
+
+    StyledNode maxWidth(float maxWidth) {
+      mNode.setMaxWidth(maxWidth);
+      return this;
+    }
+
+    StyledNode maxWidthPercent(float maxWidth) {
+      mNode.setMaxWidthPercent(maxWidth);
+      return this;
+    }
+
+    StyledNode maxHeight(float maxHeight) {
+      mNode.setMaxHeight(maxHeight);
+      return this;
+    }
+
+    StyledNode maxHeightPercent(float maxHeight) {
+      mNode.setMaxHeightPercent(maxHeight);
+      return this;
+    }
+
+    StyledNode aspectRatio(float aspectRatio) {
+      mNode.setAspectRatio(aspectRatio);
+      return this;
+    }
+  }
+}