Add tests for style properties

Summary:
@public

The existing test suite does not check every single style property settable in Java for defaults, reads, and effect on layout.

Here, we add these test, in order to make evolving the Java/C++ bridge as safe as possible.

Reviewed By: pasqualeanatriello

Differential Revision: D8952470

fbshipit-source-id: a94933adff01c313b3f440eb5207d2cb6a54a85d

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;
+    }
+  }
+}