e224a29d1c
Summary: This change drops the year from the copyright headers and the LICENSE file. Reviewed By: yungsters Differential Revision: D9727774 fbshipit-source-id: df4fc1e4390733fe774b1a160dd41b4a3d83302a
1002 lines
26 KiB
Java
1002 lines
26 KiB
Java
/*
|
|
* Copyright (c) Facebook, Inc. and its 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 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;
|
|
}
|
|
}
|
|
}
|