382faa3f44
Summary: X-link: https://github.com/facebook/react-native/pull/41480 Pull Request resolved: https://github.com/facebook/yoga/pull/1469 The previous version of static didn't do anything inside of Yoga. Now that we're making it do something, this changes the default back to relative so that users with no errata set don't see their deafult styles changing. Reviewed By: joevilches Differential Revision: D51182955 fbshipit-source-id: c0ea357694e1367fb6786f1907dfff784b19a4bc
1017 lines
26 KiB
Java
1017 lines
26 KiB
Java
/*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* 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;
|
|
import org.junit.runner.RunWith;
|
|
import org.junit.runners.Parameterized;
|
|
|
|
@RunWith(Parameterized.class)
|
|
public class YogaNodeStylePropertiesTest {
|
|
|
|
@Parameterized.Parameters(name = "{0}")
|
|
public static Iterable<TestParametrization.NodeFactory> nodeFactories() {
|
|
return TestParametrization.nodeFactories();
|
|
}
|
|
|
|
@Parameterized.Parameter public TestParametrization.NodeFactory mNodeFactory;
|
|
|
|
private static final float UNDEFINED = YogaValue.UNDEFINED.value;
|
|
|
|
@Test
|
|
public void testDirectionDefault() {
|
|
final YogaNode node = createNode();
|
|
|
|
assertEquals(node.getStyleDirection(), YogaDirection.INHERIT);
|
|
assertEquals(node.getLayoutDirection(), YogaDirection.INHERIT);
|
|
}
|
|
|
|
@Test
|
|
public void testDirectionAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaJustify.FLEX_START, node.getJustifyContent());
|
|
}
|
|
|
|
@Test
|
|
public void testJustifyContentAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaAlign.STRETCH, node.getAlignItems());
|
|
}
|
|
|
|
@Test
|
|
public void testAlignItemsAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaAlign.AUTO, node.getAlignSelf());
|
|
}
|
|
|
|
@Test
|
|
public void testAlignSelfAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaAlign.FLEX_START, node.getAlignContent());
|
|
}
|
|
|
|
@Test
|
|
public void testAlignContentAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaPositionType.RELATIVE, node.getPositionType());
|
|
}
|
|
|
|
@Test
|
|
public void testPositionTypeAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaOverflow.VISIBLE, node.getOverflow());
|
|
}
|
|
|
|
@Test
|
|
public void testOverflowAssignment() {
|
|
final YogaNode node = createNode();
|
|
node.setOverflow(YogaOverflow.SCROLL);
|
|
|
|
assertEquals(YogaOverflow.SCROLL, node.getOverflow());
|
|
}
|
|
|
|
// TODO add testOverflowAffectsLayout()
|
|
|
|
@Test
|
|
public void testDisplayDefault() {
|
|
final YogaNode node = createNode();
|
|
|
|
assertEquals(YogaDisplay.FLEX, node.getDisplay());
|
|
}
|
|
|
|
@Test
|
|
public void testDisplayAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(0, node.getFlexGrow(), 0);
|
|
}
|
|
|
|
@Test
|
|
public void testFlexGrowAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(0, node.getFlexShrink(), 0);
|
|
}
|
|
|
|
@Test
|
|
public void testFlexShrinkAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaValue.AUTO, node.getFlexBasis());
|
|
}
|
|
|
|
@Test
|
|
public void testFlexBasisAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
for (YogaEdge edge : YogaEdge.values()) {
|
|
assertEquals(YogaValue.UNDEFINED, node.getMargin(edge));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testMarginAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 testNegativeMarginAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
for (YogaEdge edge : YogaEdge.values()) {
|
|
assertEquals(YogaValue.UNDEFINED, node.getPadding(edge));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testPaddingAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
for (YogaEdge edge : YogaEdge.values()) {
|
|
assertEquals(UNDEFINED, node.getBorder(edge), 0);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testBorderAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
for (YogaEdge edge : YogaEdge.values()) {
|
|
assertEquals(YogaValue.UNDEFINED, node.getPosition(edge));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testPositionAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaValue.AUTO, node.getWidth());
|
|
}
|
|
|
|
@Test
|
|
public void testWidthAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaValue.AUTO, node.getHeight());
|
|
}
|
|
|
|
@Test
|
|
public void testHeightAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaValue.UNDEFINED, node.getMinWidth());
|
|
}
|
|
|
|
@Test
|
|
public void testMinWidthAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaValue.UNDEFINED, node.getMinHeight());
|
|
}
|
|
|
|
@Test
|
|
public void testMinHeightAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaValue.UNDEFINED, node.getMaxWidth());
|
|
}
|
|
|
|
@Test
|
|
public void testMaxWidthAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(YogaValue.UNDEFINED, node.getMaxHeight());
|
|
}
|
|
|
|
@Test
|
|
public void testMaxHeightAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 = createNode();
|
|
|
|
assertEquals(UNDEFINED, node.getAspectRatio(), 0);
|
|
}
|
|
|
|
@Test
|
|
public void testAspectRatioAssignment() {
|
|
final YogaNode node = createNode();
|
|
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 YogaNode createNode() {
|
|
return mNodeFactory.create();
|
|
}
|
|
|
|
private StyledNode style() {
|
|
return new StyledNode(mNodeFactory);
|
|
}
|
|
|
|
private static class StyledNode {
|
|
|
|
private YogaNode mNode;
|
|
|
|
public StyledNode(TestParametrization.NodeFactory nodeFactory) {
|
|
mNode = nodeFactory.create();
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|