DaddyFrosty/yoga
1
0
Fork 0
Code Issues 96 Pull Requests 31 Actions Packages Projects Releases 33 Wiki Activity

Add feature to use percentage as value unit #258

Closed
woehrl01 wants to merge 43 commits from percentage-feature into master
pull from: percentage-feature
merge into: DaddyFrosty:master
Conversation 118 Commits 43 Files Changed 41 +4401 -2509
60 changed files with 4401 additions and 2509 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit a7003b6821 - Show all commits

22
gentest/gentest-cpp.js
View File

@@ -12,7 +12,7 @@ function toValueCpp(value) {
return n + (Number(n) == n && n % 1 !== 0 ? 'f' : '');
}
function toValueCppWithUnitCpp(value) {
function toValueCppCpp(value) {
var methodName = '';
if(value.indexOf('px') >= 0){
methodName = 'YGPx';
@@ -164,7 +164,7 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {
}},
YGNodeStyleSetFlexBasis:{value:function(nodeName, value) {
this.push('YGNodeStyleSetFlexBasisWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');');
this.push('YGNodeStyleSetFlexBasis(' + nodeName + ', ' + toValueCppCpp(value) + ');');
}},
YGNodeStyleSetFlexDirection:{value:function(nodeName, value) {
@@ -184,7 +184,7 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {
}},
YGNodeStyleSetHeight:{value:function(nodeName, value) {
this.push('YGNodeStyleSetHeightWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');');
this.push('YGNodeStyleSetHeight(' + nodeName + ', ' + toValueCppCpp(value) + ');');
}},
YGNodeStyleSetJustifyContent:{value:function(nodeName, value) {
@@ -192,23 +192,23 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {
}},
YGNodeStyleSetMargin:{value:function(nodeName, edge, value) {
this.push('YGNodeStyleSetMarginWithUnit(' + nodeName + ', ' + edge + ', ' + toValueCppWithUnitCpp(value) + ');');
this.push('YGNodeStyleSetMargin(' + nodeName + ', ' + edge + ', ' + toValueCppCpp(value) + ');');
}},
YGNodeStyleSetMaxHeight:{value:function(nodeName, value) {
this.push('YGNodeStyleSetMaxHeightWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');');
this.push('YGNodeStyleSetMaxHeight(' + nodeName + ', ' + toValueCppCpp(value) + ');');
}},
YGNodeStyleSetMaxWidth:{value:function(nodeName, value) {
this.push('YGNodeStyleSetMaxWidthWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');');
this.push('YGNodeStyleSetMaxWidth(' + nodeName + ', ' + toValueCppCpp(value) + ');');
}},
YGNodeStyleSetMinHeight:{value:function(nodeName, value) {
this.push('YGNodeStyleSetMinHeightWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');');
this.push('YGNodeStyleSetMinHeight(' + nodeName + ', ' + toValueCppCpp(value) + ');');
}},
YGNodeStyleSetMinWidth:{value:function(nodeName, value) {
this.push('YGNodeStyleSetMinWidthWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');');
this.push('YGNodeStyleSetMinWidth(' + nodeName + ', ' + toValueCppCpp(value) + ');');
}},
YGNodeStyleSetOverflow:{value:function(nodeName, value) {
@@ -216,11 +216,11 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {
}},
YGNodeStyleSetPadding:{value:function(nodeName, edge, value) {
this.push('YGNodeStyleSetPaddingWithUnit(' + nodeName + ', ' + edge + ', ' + toValueCppWithUnitCpp(value) + ');');
this.push('YGNodeStyleSetPadding(' + nodeName + ', ' + edge + ', ' + toValueCppCpp(value) + ');');
}},
YGNodeStyleSetPosition:{value:function(nodeName, edge, value) {
this.push('YGNodeStyleSetPositionWithUnit(' + nodeName + ', ' + edge + ', ' + toValueCppWithUnitCpp(value) + ');');
this.push('YGNodeStyleSetPosition(' + nodeName + ', ' + edge + ', ' + toValueCppCpp(value) + ');');
}},
YGNodeStyleSetPositionType:{value:function(nodeName, value) {
@@ -228,6 +228,6 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {
}},
YGNodeStyleSetWidth:{value:function(nodeName, value) {
this.push('YGNodeStyleSetWidthWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');');
this.push('YGNodeStyleSetWidth(' + nodeName + ', ' + toValueCppCpp(value) + ');');
}},
});

100
tests/YGAbsolutePositionTest.cpp
View File

@@ -14,15 +14,15 @@
TEST(YogaTest, absolute_layout_width_height_start_top) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute);
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -53,15 +53,15 @@ TEST(YogaTest, absolute_layout_width_height_start_top) {
TEST(YogaTest, absolute_layout_width_height_end_bottom) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute);
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeEnd, YGPx(10));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeBottom, YGPx(10));
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeEnd, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeBottom, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -92,15 +92,15 @@ TEST(YogaTest, absolute_layout_width_height_end_bottom) {
TEST(YogaTest, absolute_layout_start_top_end_bottom) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute);
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeEnd, YGPx(10));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeBottom, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeEnd, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeBottom, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -131,17 +131,17 @@ TEST(YogaTest, absolute_layout_start_top_end_bottom) {
TEST(YogaTest, absolute_layout_width_height_start_top_end_bottom) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute);
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeEnd, YGPx(10));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeBottom, YGPx(10));
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeEnd, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeBottom, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -174,18 +174,18 @@ TEST(YogaTest, do_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hi
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetOverflow(root, YGOverflowHidden);
YGNodeStyleSetWidthWithUnit(root, YGPx(50));
YGNodeStyleSetHeightWithUnit(root, YGPx(50));
YGNodeStyleSetWidth(root, YGPx(50));
YGNodeStyleSetHeight(root, YGPx(50));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute);
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeStart, YGPx(0));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPx(0));
YGNodeStyleSetPosition(root_child0, YGEdgeStart, YGPx(0));
YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPx(0));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child0_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0_child0, YGPx(100));
YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(100));
YGNodeStyleSetWidth(root_child0_child0, YGPx(100));
YGNodeStyleSetHeight(root_child0_child0, YGPx(100));
YGNodeInsertChild(root_child0, root_child0_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -226,35 +226,35 @@ TEST(YogaTest, do_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hi
TEST(YogaTest, absolute_layout_within_border) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetMarginWithUnit(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetMarginWithUnit(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetMarginWithUnit(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetMarginWithUnit(root, YGEdgeBottom, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(10));
YGNodeStyleSetMargin(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetMargin(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetMargin(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetMargin(root, YGEdgeBottom, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(10));
YGNodeStyleSetBorder(root, YGEdgeLeft, 10);
YGNodeStyleSetBorder(root, YGEdgeTop, 10);
YGNodeStyleSetBorder(root, YGEdgeRight, 10);
YGNodeStyleSetBorder(root, YGEdgeBottom, 10);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute);
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeLeft, YGPx(0));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPx(0));
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(50));
YGNodeStyleSetPosition(root_child0, YGEdgeLeft, YGPx(0));
YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPx(0));
YGNodeStyleSetWidth(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(50));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetPositionType(root_child1, YGPositionTypeAbsolute);
YGNodeStyleSetPositionWithUnit(root_child1, YGEdgeRight, YGPx(0));
YGNodeStyleSetPositionWithUnit(root_child1, YGEdgeBottom, YGPx(0));
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(50));
YGNodeStyleSetPosition(root_child1, YGEdgeRight, YGPx(0));
YGNodeStyleSetPosition(root_child1, YGEdgeBottom, YGPx(0));
YGNodeStyleSetWidth(root_child1, YGPx(50));
YGNodeStyleSetHeight(root_child1, YGPx(50));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

86
tests/YGAlignContentTest.cpp
View File

@@ -15,32 +15,32 @@
TEST(YogaTest, align_content_flex_start) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexWrap(root, YGWrapWrap);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(50));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(50));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
const YGNodeRef root_child3 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child3, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child3, YGPx(10));
YGNodeStyleSetWidth(root_child3, YGPx(50));
YGNodeStyleSetHeight(root_child3, YGPx(10));
YGNodeInsertChild(root, root_child3, 3);
const YGNodeRef root_child4 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child4, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child4, YGPx(10));
YGNodeStyleSetWidth(root_child4, YGPx(50));
YGNodeStyleSetHeight(root_child4, YGPx(10));
YGNodeInsertChild(root, root_child4, 4);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -113,32 +113,32 @@ TEST(YogaTest, align_content_flex_end) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignContent(root, YGAlignFlexEnd);
YGNodeStyleSetFlexWrap(root, YGWrapWrap);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(50));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(50));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
const YGNodeRef root_child3 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child3, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child3, YGPx(10));
YGNodeStyleSetWidth(root_child3, YGPx(50));
YGNodeStyleSetHeight(root_child3, YGPx(10));
YGNodeInsertChild(root, root_child3, 3);
const YGNodeRef root_child4 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child4, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child4, YGPx(10));
YGNodeStyleSetWidth(root_child4, YGPx(50));
YGNodeStyleSetHeight(root_child4, YGPx(10));
YGNodeInsertChild(root, root_child4, 4);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -211,32 +211,32 @@ TEST(YogaTest, align_content_center) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignContent(root, YGAlignCenter);
YGNodeStyleSetFlexWrap(root, YGWrapWrap);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(50));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(50));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
const YGNodeRef root_child3 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child3, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child3, YGPx(10));
YGNodeStyleSetWidth(root_child3, YGPx(50));
YGNodeStyleSetHeight(root_child3, YGPx(10));
YGNodeInsertChild(root, root_child3, 3);
const YGNodeRef root_child4 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child4, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child4, YGPx(10));
YGNodeStyleSetWidth(root_child4, YGPx(50));
YGNodeStyleSetHeight(root_child4, YGPx(10));
YGNodeInsertChild(root, root_child4, 4);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -309,27 +309,27 @@ TEST(YogaTest, align_content_stretch) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignContent(root, YGAlignStretch);
YGNodeStyleSetFlexWrap(root, YGWrapWrap);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50));
YGNodeStyleSetWidth(root_child0, YGPx(50));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50));
YGNodeStyleSetWidth(root_child1, YGPx(50));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50));
YGNodeStyleSetWidth(root_child2, YGPx(50));
YGNodeInsertChild(root, root_child2, 2);
const YGNodeRef root_child3 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child3, YGPx(50));
YGNodeStyleSetWidth(root_child3, YGPx(50));
YGNodeInsertChild(root, root_child3, 3);
const YGNodeRef root_child4 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child4, YGPx(50));
YGNodeStyleSetWidth(root_child4, YGPx(50));
YGNodeInsertChild(root, root_child4, 4);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

30
tests/YGAlignItemsTest.cpp
View File

@@ -14,11 +14,11 @@
TEST(YogaTest, align_items_stretch) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -50,12 +50,12 @@ TEST(YogaTest, align_items_stretch) {
TEST(YogaTest, align_items_center) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignItems(root, YGAlignCenter);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -87,12 +87,12 @@ TEST(YogaTest, align_items_center) {
TEST(YogaTest, align_items_flex_start) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignItems(root, YGAlignFlexStart);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -124,12 +124,12 @@ TEST(YogaTest, align_items_flex_start) {
TEST(YogaTest, align_items_flex_end) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignItems(root, YGAlignFlexEnd);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

32
tests/YGAlignSelfTest.cpp
View File

@@ -14,13 +14,13 @@
TEST(YogaTest, align_self_center) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetAlignSelf(root_child0, YGAlignCenter);
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -51,13 +51,13 @@ TEST(YogaTest, align_self_center) {
TEST(YogaTest, align_self_flex_end) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexEnd);
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -88,13 +88,13 @@ TEST(YogaTest, align_self_flex_end) {
TEST(YogaTest, align_self_flex_start) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexStart);
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -126,13 +126,13 @@ TEST(YogaTest, align_self_flex_start) {
TEST(YogaTest, align_self_flex_end_override_flex_start) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignItems(root, YGAlignFlexStart);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexEnd);
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

24
tests/YGBorderTest.cpp
View File

@@ -43,8 +43,8 @@ TEST(YogaTest, border_container_match_child) {
YGNodeStyleSetBorder(root, YGEdgeBottom, 10);
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -79,12 +79,12 @@ TEST(YogaTest, border_flex_child) {
YGNodeStyleSetBorder(root, YGEdgeTop, 10);
YGNodeStyleSetBorder(root, YGEdgeRight, 10);
YGNodeStyleSetBorder(root, YGEdgeBottom, 10);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -119,11 +119,11 @@ TEST(YogaTest, border_stretch_child) {
YGNodeStyleSetBorder(root, YGEdgeTop, 10);
YGNodeStyleSetBorder(root, YGEdgeRight, 10);
YGNodeStyleSetBorder(root, YGEdgeBottom, 10);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -159,12 +159,12 @@ TEST(YogaTest, border_center_child) {
YGNodeStyleSetBorder(root, YGEdgeStart, 10);
YGNodeStyleSetBorder(root, YGEdgeEnd, 20);
YGNodeStyleSetBorder(root, YGEdgeBottom, 20);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

36
tests/YGDirtyMarkingTest.cpp
View File

@@ -13,22 +13,22 @@
TEST(YogaTest, dirty_propagation) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignItems(root, YGAlignFlexStart);
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidth(root_child0, 50);
YGNodeStyleSetHeight(root_child0, 20);
YGNodeStyleSetWidth(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidth(root_child1, 50);
YGNodeStyleSetHeight(root_child1, 20);
YGNodeStyleSetWidth(root_child1, YGPx(50));
YGNodeStyleSetHeight(root_child1, YGPx(20));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
YGNodeStyleSetWidth(root_child0, 20);
YGNodeStyleSetWidth(root_child0, YGPx(20));
EXPECT_TRUE(YGNodeIsDirty(root_child0));
EXPECT_FALSE(YGNodeIsDirty(root_child1));
@@ -46,22 +46,22 @@ TEST(YogaTest, dirty_propagation) {
TEST(YogaTest, dirty_propagation_only_if_prop_changed) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignItems(root, YGAlignFlexStart);
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidth(root_child0, 50);
YGNodeStyleSetHeight(root_child0, 20);
YGNodeStyleSetWidth(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidth(root_child1, 50);
YGNodeStyleSetHeight(root_child1, 20);
YGNodeStyleSetWidth(root_child1, YGPx(50));
YGNodeStyleSetHeight(root_child1, YGPx(20));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
YGNodeStyleSetWidth(root_child0, 50);
YGNodeStyleSetWidth(root_child0, YGPx(50));
EXPECT_FALSE(YGNodeIsDirty(root_child0));
EXPECT_FALSE(YGNodeIsDirty(root_child1));
@@ -73,12 +73,12 @@ TEST(YogaTest, dirty_propagation_only_if_prop_changed) {
TEST(YogaTest, dirty_node_only_if_children_are_actually_removed) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignItems(root, YGAlignFlexStart);
YGNodeStyleSetWidth(root, 50);
YGNodeStyleSetHeight(root, 50);
YGNodeStyleSetWidth(root, YGPx(50));
YGNodeStyleSetHeight(root, YGPx(50));
const YGNodeRef child0 = YGNodeNew();
YGNodeStyleSetWidth(child0, 50);
YGNodeStyleSetHeight(child0, 25);
YGNodeStyleSetWidth(child0, YGPx(50));
YGNodeStyleSetHeight(child0, YGPx(25));
YGNodeInsertChild(root, child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

66
tests/YGEdgeTest.cpp
View File

@@ -13,14 +13,14 @@
TEST(YogaTest, start_overrides) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMargin(root_child0, YGEdgeStart, 10);
YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 20);
YGNodeStyleSetMargin(root_child0, YGEdgeRight, 20);
YGNodeStyleSetMargin(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPx(20));
YGNodeStyleSetMargin(root_child0, YGEdgeRight, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -37,14 +37,14 @@ TEST(YogaTest, start_overrides) {
TEST(YogaTest, end_overrides) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMargin(root_child0, YGEdgeEnd, 10);
YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 20);
YGNodeStyleSetMargin(root_child0, YGEdgeRight, 20);
YGNodeStyleSetMargin(root_child0, YGEdgeEnd, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPx(20));
YGNodeStyleSetMargin(root_child0, YGEdgeRight, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -61,13 +61,13 @@ TEST(YogaTest, end_overrides) {
TEST(YogaTest, horizontal_overridden) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMargin(root_child0, YGEdgeHorizontal, 10);
YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 20);
YGNodeStyleSetMargin(root_child0, YGEdgeHorizontal, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -80,13 +80,13 @@ TEST(YogaTest, horizontal_overridden) {
TEST(YogaTest, vertical_overridden) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumn);
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMargin(root_child0, YGEdgeVertical, 10);
YGNodeStyleSetMargin(root_child0, YGEdgeTop, 20);
YGNodeStyleSetMargin(root_child0, YGEdgeVertical, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -99,13 +99,13 @@ TEST(YogaTest, vertical_overridden) {
TEST(YogaTest, horizontal_overrides_all) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumn);
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMargin(root_child0, YGEdgeHorizontal, 10);
YGNodeStyleSetMargin(root_child0, YGEdgeAll, 20);
YGNodeStyleSetMargin(root_child0, YGEdgeHorizontal, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeAll, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -120,13 +120,13 @@ TEST(YogaTest, horizontal_overrides_all) {
TEST(YogaTest, vertical_overrides_all) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumn);
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMargin(root_child0, YGEdgeVertical, 10);
YGNodeStyleSetMargin(root_child0, YGEdgeAll, 20);
YGNodeStyleSetMargin(root_child0, YGEdgeVertical, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeAll, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -141,16 +141,16 @@ TEST(YogaTest, vertical_overrides_all) {
TEST(YogaTest, all_overridden) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumn);
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 10);
YGNodeStyleSetMargin(root_child0, YGEdgeTop, 10);
YGNodeStyleSetMargin(root_child0, YGEdgeRight, 10);
YGNodeStyleSetMargin(root_child0, YGEdgeBottom, 10);
YGNodeStyleSetMargin(root_child0, YGEdgeAll, 20);
YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeRight, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeBottom, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeAll, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

56
tests/YGFlexDirectionTest.cpp
View File

@@ -14,18 +14,18 @@
TEST(YogaTest, flex_direction_column_no_height) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -77,18 +77,18 @@ TEST(YogaTest, flex_direction_column_no_height) {
TEST(YogaTest, flex_direction_row_no_width) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -139,19 +139,19 @@ TEST(YogaTest, flex_direction_row_no_width) {
TEST(YogaTest, flex_direction_column) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -203,19 +203,19 @@ TEST(YogaTest, flex_direction_column) {
TEST(YogaTest, flex_direction_row) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -267,19 +267,19 @@ TEST(YogaTest, flex_direction_row) {
TEST(YogaTest, flex_direction_column_reverse) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumnReverse);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -331,19 +331,19 @@ TEST(YogaTest, flex_direction_column_reverse) {
TEST(YogaTest, flex_direction_row_reverse) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRowReverse);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

58
tests/YGFlexTest.cpp
View File

@@ -14,12 +14,12 @@
TEST(YogaTest, flex_basis_flex_grow_column) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50));
YGNodeStyleSetFlexBasis(root_child0, YGPx(50));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
@@ -65,12 +65,12 @@ TEST(YogaTest, flex_basis_flex_grow_column) {
TEST(YogaTest, flex_basis_flex_grow_row) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50));
YGNodeStyleSetFlexBasis(root_child0, YGPx(50));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
@@ -115,16 +115,16 @@ TEST(YogaTest, flex_basis_flex_grow_row) {
TEST(YogaTest, flex_basis_flex_shrink_column) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexShrink(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(100));
YGNodeStyleSetFlexBasis(root_child0, YGPx(100));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPx(50));
YGNodeStyleSetFlexBasis(root_child1, YGPx(50));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -166,16 +166,16 @@ TEST(YogaTest, flex_basis_flex_shrink_column) {
TEST(YogaTest, flex_basis_flex_shrink_row) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexShrink(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(100));
YGNodeStyleSetFlexBasis(root_child0, YGPx(100));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPx(50));
YGNodeStyleSetFlexBasis(root_child1, YGPx(50));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -216,22 +216,22 @@ TEST(YogaTest, flex_basis_flex_shrink_row) {
TEST(YogaTest, flex_shrink_to_zero) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root, YGPx(75));
YGNodeStyleSetHeight(root, YGPx(75));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(50));
YGNodeStyleSetWidth(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(50));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexShrink(root_child1, 1);
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(50));
YGNodeStyleSetWidth(root_child1, YGPx(50));
YGNodeStyleSetHeight(root_child1, YGPx(50));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(50));
YGNodeStyleSetWidth(root_child2, YGPx(50));
YGNodeStyleSetHeight(root_child2, YGPx(50));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -282,23 +282,23 @@ TEST(YogaTest, flex_shrink_to_zero) {
TEST(YogaTest, flex_basis_overrides_main_size) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20));
YGNodeStyleSetFlexBasis(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 1);
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child2, 1);
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -349,8 +349,8 @@ TEST(YogaTest, flex_basis_overrides_main_size) {
TEST(YogaTest, flex_grow_shrink_at_most) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeInsertChild(root, root_child0, 0);

72
tests/YGFlexWrapTest.cpp
View File

@@ -15,26 +15,26 @@
TEST(YogaTest, wrap_column) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexWrap(root, YGWrapWrap);
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(30));
YGNodeStyleSetWidth(root_child0, YGPx(30));
YGNodeStyleSetHeight(root_child0, YGPx(30));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(30));
YGNodeStyleSetWidth(root_child1, YGPx(30));
YGNodeStyleSetHeight(root_child1, YGPx(30));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(30));
YGNodeStyleSetWidth(root_child2, YGPx(30));
YGNodeStyleSetHeight(root_child2, YGPx(30));
YGNodeInsertChild(root, root_child2, 2);
const YGNodeRef root_child3 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child3, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child3, YGPx(30));
YGNodeStyleSetWidth(root_child3, YGPx(30));
YGNodeStyleSetHeight(root_child3, YGPx(30));
YGNodeInsertChild(root, root_child3, 3);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -97,26 +97,26 @@ TEST(YogaTest, wrap_row) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetFlexWrap(root, YGWrapWrap);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(30));
YGNodeStyleSetWidth(root_child0, YGPx(30));
YGNodeStyleSetHeight(root_child0, YGPx(30));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(30));
YGNodeStyleSetWidth(root_child1, YGPx(30));
YGNodeStyleSetHeight(root_child1, YGPx(30));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(30));
YGNodeStyleSetWidth(root_child2, YGPx(30));
YGNodeStyleSetHeight(root_child2, YGPx(30));
YGNodeInsertChild(root, root_child2, 2);
const YGNodeRef root_child3 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child3, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child3, YGPx(30));
YGNodeStyleSetWidth(root_child3, YGPx(30));
YGNodeStyleSetHeight(root_child3, YGPx(30));
YGNodeInsertChild(root, root_child3, 3);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -180,26 +180,26 @@ TEST(YogaTest, wrap_row_align_items_flex_end) {
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetAlignItems(root, YGAlignFlexEnd);
YGNodeStyleSetFlexWrap(root, YGWrapWrap);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(30));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(20));
YGNodeStyleSetWidth(root_child1, YGPx(30));
YGNodeStyleSetHeight(root_child1, YGPx(20));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(30));
YGNodeStyleSetWidth(root_child2, YGPx(30));
YGNodeStyleSetHeight(root_child2, YGPx(30));
YGNodeInsertChild(root, root_child2, 2);
const YGNodeRef root_child3 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child3, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child3, YGPx(30));
YGNodeStyleSetWidth(root_child3, YGPx(30));
YGNodeStyleSetHeight(root_child3, YGPx(30));
YGNodeInsertChild(root, root_child3, 3);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -263,26 +263,26 @@ TEST(YogaTest, wrap_row_align_items_center) {
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetAlignItems(root, YGAlignCenter);
YGNodeStyleSetFlexWrap(root, YGWrapWrap);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(30));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(20));
YGNodeStyleSetWidth(root_child1, YGPx(30));
YGNodeStyleSetHeight(root_child1, YGPx(20));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(30));
YGNodeStyleSetWidth(root_child2, YGPx(30));
YGNodeStyleSetHeight(root_child2, YGPx(30));
YGNodeInsertChild(root, root_child2, 2);
const YGNodeRef root_child3 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child3, YGPx(30));
YGNodeStyleSetHeightWithUnit(root_child3, YGPx(30));
YGNodeStyleSetWidth(root_child3, YGPx(30));
YGNodeStyleSetHeight(root_child3, YGPx(30));
YGNodeInsertChild(root, root_child3, 3);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

98
tests/YGJustifyContentTest.cpp
View File

@@ -15,19 +15,19 @@
TEST(YogaTest, justify_content_row_flex_start) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(102));
YGNodeStyleSetHeightWithUnit(root, YGPx(102));
YGNodeStyleSetWidth(root, YGPx(102));
YGNodeStyleSetHeight(root, YGPx(102));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -80,19 +80,19 @@ TEST(YogaTest, justify_content_row_flex_end) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd);
YGNodeStyleSetWidthWithUnit(root, YGPx(102));
YGNodeStyleSetHeightWithUnit(root, YGPx(102));
YGNodeStyleSetWidth(root, YGPx(102));
YGNodeStyleSetHeight(root, YGPx(102));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -145,19 +145,19 @@ TEST(YogaTest, justify_content_row_center) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
YGNodeStyleSetWidthWithUnit(root, YGPx(102));
YGNodeStyleSetHeightWithUnit(root, YGPx(102));
YGNodeStyleSetWidth(root, YGPx(102));
YGNodeStyleSetHeight(root, YGPx(102));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -210,19 +210,19 @@ TEST(YogaTest, justify_content_row_space_between) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetJustifyContent(root, YGJustifySpaceBetween);
YGNodeStyleSetWidthWithUnit(root, YGPx(102));
YGNodeStyleSetHeightWithUnit(root, YGPx(102));
YGNodeStyleSetWidth(root, YGPx(102));
YGNodeStyleSetHeight(root, YGPx(102));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -275,19 +275,19 @@ TEST(YogaTest, justify_content_row_space_around) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetJustifyContent(root, YGJustifySpaceAround);
YGNodeStyleSetWidthWithUnit(root, YGPx(102));
YGNodeStyleSetHeightWithUnit(root, YGPx(102));
YGNodeStyleSetWidth(root, YGPx(102));
YGNodeStyleSetHeight(root, YGPx(102));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10));
YGNodeStyleSetWidth(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10));
YGNodeStyleSetWidth(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -338,18 +338,18 @@ TEST(YogaTest, justify_content_row_space_around) {
TEST(YogaTest, justify_content_column_flex_start) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(102));
YGNodeStyleSetHeightWithUnit(root, YGPx(102));
YGNodeStyleSetWidth(root, YGPx(102));
YGNodeStyleSetHeight(root, YGPx(102));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -401,19 +401,19 @@ TEST(YogaTest, justify_content_column_flex_start) {
TEST(YogaTest, justify_content_column_flex_end) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd);
YGNodeStyleSetWidthWithUnit(root, YGPx(102));
YGNodeStyleSetHeightWithUnit(root, YGPx(102));
YGNodeStyleSetWidth(root, YGPx(102));
YGNodeStyleSetHeight(root, YGPx(102));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -465,19 +465,19 @@ TEST(YogaTest, justify_content_column_flex_end) {
TEST(YogaTest, justify_content_column_center) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
YGNodeStyleSetWidthWithUnit(root, YGPx(102));
YGNodeStyleSetHeightWithUnit(root, YGPx(102));
YGNodeStyleSetWidth(root, YGPx(102));
YGNodeStyleSetHeight(root, YGPx(102));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -529,19 +529,19 @@ TEST(YogaTest, justify_content_column_center) {
TEST(YogaTest, justify_content_column_space_between) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetJustifyContent(root, YGJustifySpaceBetween);
YGNodeStyleSetWidthWithUnit(root, YGPx(102));
YGNodeStyleSetHeightWithUnit(root, YGPx(102));
YGNodeStyleSetWidth(root, YGPx(102));
YGNodeStyleSetHeight(root, YGPx(102));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -593,19 +593,19 @@ TEST(YogaTest, justify_content_column_space_between) {
TEST(YogaTest, justify_content_column_space_around) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetJustifyContent(root, YGJustifySpaceAround);
YGNodeStyleSetWidthWithUnit(root, YGPx(102));
YGNodeStyleSetHeightWithUnit(root, YGPx(102));
YGNodeStyleSetWidth(root, YGPx(102));
YGNodeStyleSetHeight(root, YGPx(102));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

50
tests/YGLayoutDefaultValuesTest.cpp
View File

@@ -27,28 +27,28 @@ TEST(YogaTest, assert_default_values) {
ASSERT_EQ(YGOverflowVisible, YGNodeStyleGetOverflow(root));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetFlexGrow(root));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetFlexShrink(root));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetFlexBasis(root)));
ASSERT_FALSE(YGNodeStyleGetFlexBasis(root).defined);
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeLeft)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeTop)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeRight)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeBottom)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeStart)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeEnd)));
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeLeft).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeTop).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeRight).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeBottom).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeStart).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeEnd).defined);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeLeft));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeTop));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeRight));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeBottom));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMargin(root, YGEdgeStart)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMargin(root, YGEdgeEnd)));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeLeft).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeTop).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeRight).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeBottom).value);
ASSERT_FALSE(YGNodeStyleGetMargin(root, YGEdgeStart).defined);
ASSERT_FALSE(YGNodeStyleGetMargin(root, YGEdgeEnd).defined);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeLeft));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeTop));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeRight));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeBottom));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPadding(root, YGEdgeStart)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPadding(root, YGEdgeEnd)));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeLeft).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeTop).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeRight).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeBottom).value);
ASSERT_FALSE(YGNodeStyleGetPadding(root, YGEdgeStart).defined);
ASSERT_FALSE(YGNodeStyleGetPadding(root, YGEdgeEnd).defined);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetBorder(root, YGEdgeLeft));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetBorder(root, YGEdgeTop));
@@ -57,12 +57,12 @@ TEST(YogaTest, assert_default_values) {
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetBorder(root, YGEdgeStart)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetBorder(root, YGEdgeEnd)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetWidth(root)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetHeight(root)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMinWidth(root)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMinHeight(root)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMaxWidth(root)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMaxHeight(root)));
ASSERT_FALSE(YGNodeStyleGetWidth(root).defined);
ASSERT_FALSE(YGNodeStyleGetHeight(root).defined);
ASSERT_FALSE(YGNodeStyleGetMinWidth(root).defined);
ASSERT_FALSE(YGNodeStyleGetMinHeight(root).defined);
ASSERT_FALSE(YGNodeStyleGetMaxWidth(root).defined);
ASSERT_FALSE(YGNodeStyleGetMaxHeight(root).defined);
ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));

64
tests/YGMarginTest.cpp
View File

@@ -15,12 +15,12 @@
TEST(YogaTest, margin_start) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -51,12 +51,12 @@ TEST(YogaTest, margin_start) {
TEST(YogaTest, margin_top) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -89,12 +89,12 @@ TEST(YogaTest, margin_end) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeEnd, YGPx(10));
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeEnd, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -126,12 +126,12 @@ TEST(YogaTest, margin_end) {
TEST(YogaTest, margin_bottom) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeBottom, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeBottom, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -163,12 +163,12 @@ TEST(YogaTest, margin_bottom) {
TEST(YogaTest, margin_and_flex_row) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeStart, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -199,12 +199,12 @@ TEST(YogaTest, margin_and_flex_row) {
TEST(YogaTest, margin_and_flex_column) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -236,12 +236,12 @@ TEST(YogaTest, margin_and_flex_column) {
TEST(YogaTest, margin_and_stretch_row) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeTop, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -272,12 +272,12 @@ TEST(YogaTest, margin_and_stretch_row) {
TEST(YogaTest, margin_and_stretch_column) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeStart, YGPx(10));
YGNodeStyleSetMargin(root_child0, YGEdgeStart, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -309,8 +309,8 @@ TEST(YogaTest, margin_and_stretch_column) {
TEST(YogaTest, margin_with_sibling_row) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
@@ -358,8 +358,8 @@ TEST(YogaTest, margin_with_sibling_row) {
TEST(YogaTest, margin_with_sibling_column) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);

80
tests/YGMinMaxDimensionTest.cpp
View File

@@ -14,12 +14,12 @@
TEST(YogaTest, max_width) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetMaxWidthWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetMaxWidth(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -51,12 +51,12 @@ TEST(YogaTest, max_width) {
TEST(YogaTest, max_height) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetMaxHeightWithUnit(root_child0, YGPx(50));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetMaxHeight(root_child0, YGPx(50));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -87,12 +87,12 @@ TEST(YogaTest, max_height) {
TEST(YogaTest, min_height) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMinHeightWithUnit(root_child0, YGPx(60));
YGNodeStyleSetMinHeight(root_child0, YGPx(60));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
@@ -138,12 +138,12 @@ TEST(YogaTest, min_height) {
TEST(YogaTest, min_width) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMinWidthWithUnit(root_child0, YGPx(60));
YGNodeStyleSetMinWidth(root_child0, YGPx(60));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
@@ -189,13 +189,13 @@ TEST(YogaTest, min_width) {
TEST(YogaTest, justify_content_min_max) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetMinHeightWithUnit(root, YGPx(100));
YGNodeStyleSetMaxHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetMinHeight(root, YGPx(100));
YGNodeStyleSetMaxHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(60));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(60));
YGNodeStyleSetWidth(root_child0, YGPx(60));
YGNodeStyleSetHeight(root_child0, YGPx(60));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -227,13 +227,13 @@ TEST(YogaTest, justify_content_min_max) {
TEST(YogaTest, align_items_min_max) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetAlignItems(root, YGAlignCenter);
YGNodeStyleSetMinWidthWithUnit(root, YGPx(100));
YGNodeStyleSetMaxWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetMinWidth(root, YGPx(100));
YGNodeStyleSetMaxWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(60));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(60));
YGNodeStyleSetWidth(root_child0, YGPx(60));
YGNodeStyleSetHeight(root_child0, YGPx(60));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -265,22 +265,22 @@ TEST(YogaTest, align_items_min_max) {
TEST(YogaTest, justify_content_overflow_min_max) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
YGNodeStyleSetMinHeightWithUnit(root, YGPx(100));
YGNodeStyleSetMaxHeightWithUnit(root, YGPx(110));
YGNodeStyleSetMinHeight(root, YGPx(100));
YGNodeStyleSetMaxHeight(root, YGPx(110));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(50));
YGNodeStyleSetWidth(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(50));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(50));
YGNodeStyleSetWidth(root_child1, YGPx(50));
YGNodeStyleSetHeight(root_child1, YGPx(50));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(50));
YGNodeStyleSetWidth(root_child2, YGPx(50));
YGNodeStyleSetHeight(root_child2, YGPx(50));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -331,17 +331,17 @@ TEST(YogaTest, justify_content_overflow_min_max) {
TEST(YogaTest, flex_grow_within_max_width) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexDirection(root_child0, YGFlexDirectionRow);
YGNodeStyleSetMaxWidthWithUnit(root_child0, YGPx(100));
YGNodeStyleSetMaxWidth(root_child0, YGPx(100));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child0_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0_child0, 1);
YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(20));
YGNodeStyleSetHeight(root_child0_child0, YGPx(20));
YGNodeInsertChild(root_child0, root_child0_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -382,17 +382,17 @@ TEST(YogaTest, flex_grow_within_max_width) {
TEST(YogaTest, flex_grow_within_constrained_max_width) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexDirection(root_child0, YGFlexDirectionRow);
YGNodeStyleSetMaxWidthWithUnit(root_child0, YGPx(300));
YGNodeStyleSetMaxWidth(root_child0, YGPx(300));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child0_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0_child0, 1);
YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(20));
YGNodeStyleSetHeight(root_child0_child0, YGPx(20));
YGNodeInsertChild(root_child0, root_child0_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

78
tests/YGPaddingTest.cpp
View File

@@ -14,10 +14,10 @@
TEST(YogaTest, padding_no_size) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetPaddingWithUnit(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(10));
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
@@ -37,14 +37,14 @@ TEST(YogaTest, padding_no_size) {
TEST(YogaTest, padding_container_match_child) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetPaddingWithUnit(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(10));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -75,16 +75,16 @@ TEST(YogaTest, padding_container_match_child) {
TEST(YogaTest, padding_flex_child) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetPaddingWithUnit(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(10));
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetPadding(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(10));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -115,15 +115,15 @@ TEST(YogaTest, padding_flex_child) {
TEST(YogaTest, padding_stretch_child) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetPaddingWithUnit(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(10));
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetPadding(root, YGEdgeLeft, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeTop, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeRight, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(10));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -156,15 +156,15 @@ TEST(YogaTest, padding_center_child) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
YGNodeStyleSetAlignItems(root, YGAlignCenter);
YGNodeStyleSetPaddingWithUnit(root, YGEdgeStart, YGPx(10));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeEnd, YGPx(20));
YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(20));
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetPadding(root, YGEdgeStart, YGPx(10));
YGNodeStyleSetPadding(root, YGEdgeEnd, YGPx(20));
YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(20));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -197,16 +197,16 @@ TEST(YogaTest, child_with_padding_align_end) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd);
YGNodeStyleSetAlignItems(root, YGAlignFlexEnd);
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeLeft, YGPx(20));
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeTop, YGPx(20));
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeRight, YGPx(20));
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeBottom, YGPx(20));
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(100));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(100));
YGNodeStyleSetPadding(root_child0, YGEdgeLeft, YGPx(20));
YGNodeStyleSetPadding(root_child0, YGEdgeTop, YGPx(20));
YGNodeStyleSetPadding(root_child0, YGEdgeRight, YGPx(20));
YGNodeStyleSetPadding(root_child0, YGEdgeBottom, YGPx(20));
YGNodeStyleSetWidth(root_child0, YGPx(100));
YGNodeStyleSetHeight(root_child0, YGPx(100));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

236
tests/YGPercentageTest.cpp
View File

@@ -17,12 +17,12 @@ TEST(YogaTest, percentage_width_height) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0, YGPercent(30));
YGNodeStyleSetHeightWithUnit(root_child0, YGPercent(30));
YGNodeStyleSetWidth(root_child0, YGPercent(30));
YGNodeStyleSetHeight(root_child0, YGPercent(30));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -58,14 +58,14 @@ TEST(YogaTest, percentage_position_left_top) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(400));
YGNodeStyleSetHeightWithUnit(root, YGPx(400));
YGNodeStyleSetWidth(root, YGPx(400));
YGNodeStyleSetHeight(root, YGPx(400));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeLeft, YGPercent(10));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPercent(20));
YGNodeStyleSetWidthWithUnit(root_child0, YGPercent(45));
YGNodeStyleSetHeightWithUnit(root_child0, YGPercent(55));
YGNodeStyleSetPosition(root_child0, YGEdgeLeft, YGPercent(10));
YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPercent(20));
YGNodeStyleSetWidth(root_child0, YGPercent(45));
YGNodeStyleSetHeight(root_child0, YGPercent(55));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -101,14 +101,14 @@ TEST(YogaTest, percentage_position_bottom_right) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(500));
YGNodeStyleSetHeightWithUnit(root, YGPx(500));
YGNodeStyleSetWidth(root, YGPx(500));
YGNodeStyleSetHeight(root, YGPx(500));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeRight, YGPercent(20));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeBottom, YGPercent(10));
YGNodeStyleSetWidthWithUnit(root_child0, YGPercent(55));
YGNodeStyleSetHeightWithUnit(root_child0, YGPercent(15));
YGNodeStyleSetPosition(root_child0, YGEdgeRight, YGPercent(20));
YGNodeStyleSetPosition(root_child0, YGEdgeBottom, YGPercent(10));
YGNodeStyleSetWidth(root_child0, YGPercent(55));
YGNodeStyleSetHeight(root_child0, YGPercent(15));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -144,17 +144,17 @@ TEST(YogaTest, percentage_flex_basis) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(50));
YGNodeStyleSetFlexBasis(root_child0, YGPercent(50));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(25));
YGNodeStyleSetFlexBasis(root_child1, YGPercent(25));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -199,17 +199,17 @@ TEST(YogaTest, percentage_flex_basis_cross) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(50));
YGNodeStyleSetFlexBasis(root_child0, YGPercent(50));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(25));
YGNodeStyleSetFlexBasis(root_child1, YGPercent(25));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -254,17 +254,17 @@ TEST(YogaTest, percentage_flex_basis_cross_min_height) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMinHeightWithUnit(root_child0, YGPercent(60));
YGNodeStyleSetMinHeight(root_child0, YGPercent(60));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 2);
YGNodeStyleSetMinHeightWithUnit(root_child1, YGPercent(10));
YGNodeStyleSetMinHeight(root_child1, YGPercent(10));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -310,19 +310,19 @@ TEST(YogaTest, percentage_flex_basis_main_max_height) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(10));
YGNodeStyleSetMaxHeightWithUnit(root_child0, YGPercent(60));
YGNodeStyleSetFlexBasis(root_child0, YGPercent(10));
YGNodeStyleSetMaxHeight(root_child0, YGPercent(60));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 4);
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(10));
YGNodeStyleSetMaxHeightWithUnit(root_child1, YGPercent(20));
YGNodeStyleSetFlexBasis(root_child1, YGPercent(10));
YGNodeStyleSetMaxHeight(root_child1, YGPercent(20));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -367,19 +367,19 @@ TEST(YogaTest, percentage_flex_basis_cross_max_height) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(10));
YGNodeStyleSetMaxHeightWithUnit(root_child0, YGPercent(60));
YGNodeStyleSetFlexBasis(root_child0, YGPercent(10));
YGNodeStyleSetMaxHeight(root_child0, YGPercent(60));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 4);
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(10));
YGNodeStyleSetMaxHeightWithUnit(root_child1, YGPercent(20));
YGNodeStyleSetFlexBasis(root_child1, YGPercent(10));
YGNodeStyleSetMaxHeight(root_child1, YGPercent(20));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -425,19 +425,19 @@ TEST(YogaTest, percentage_flex_basis_main_max_width) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(15));
YGNodeStyleSetMaxWidthWithUnit(root_child0, YGPercent(60));
YGNodeStyleSetFlexBasis(root_child0, YGPercent(15));
YGNodeStyleSetMaxWidth(root_child0, YGPercent(60));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 4);
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(10));
YGNodeStyleSetMaxWidthWithUnit(root_child1, YGPercent(20));
YGNodeStyleSetFlexBasis(root_child1, YGPercent(10));
YGNodeStyleSetMaxWidth(root_child1, YGPercent(20));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -482,19 +482,19 @@ TEST(YogaTest, percentage_flex_basis_cross_max_width) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(10));
YGNodeStyleSetMaxWidthWithUnit(root_child0, YGPercent(60));
YGNodeStyleSetFlexBasis(root_child0, YGPercent(10));
YGNodeStyleSetMaxWidth(root_child0, YGPercent(60));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 4);
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(15));
YGNodeStyleSetMaxWidthWithUnit(root_child1, YGPercent(20));
YGNodeStyleSetFlexBasis(root_child1, YGPercent(15));
YGNodeStyleSetMaxWidth(root_child1, YGPercent(20));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -540,19 +540,19 @@ TEST(YogaTest, percentage_flex_basis_main_min_width) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(15));
YGNodeStyleSetMinWidthWithUnit(root_child0, YGPercent(60));
YGNodeStyleSetFlexBasis(root_child0, YGPercent(15));
YGNodeStyleSetMinWidth(root_child0, YGPercent(60));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 4);
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(10));
YGNodeStyleSetMinWidthWithUnit(root_child1, YGPercent(20));
YGNodeStyleSetFlexBasis(root_child1, YGPercent(10));
YGNodeStyleSetMinWidth(root_child1, YGPercent(20));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -597,19 +597,19 @@ TEST(YogaTest, percentage_flex_basis_cross_min_width) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(10));
YGNodeStyleSetMinWidthWithUnit(root_child0, YGPercent(60));
YGNodeStyleSetFlexBasis(root_child0, YGPercent(10));
YGNodeStyleSetMinWidth(root_child0, YGPercent(60));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 4);
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(15));
YGNodeStyleSetMinWidthWithUnit(root_child1, YGPercent(20));
YGNodeStyleSetFlexBasis(root_child1, YGPercent(15));
YGNodeStyleSetMinWidth(root_child1, YGPercent(20));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -654,51 +654,51 @@ TEST(YogaTest, percentage_multiple_nested_with_padding_margin_and_percentage_val
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(200));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(200));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(10));
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeLeft, YGPx(5));
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeTop, YGPx(5));
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeRight, YGPx(5));
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeBottom, YGPx(5));
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeLeft, YGPx(3));
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeTop, YGPx(3));
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeRight, YGPx(3));
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeBottom, YGPx(3));
YGNodeStyleSetMinWidthWithUnit(root_child0, YGPercent(60));
YGNodeStyleSetFlexBasis(root_child0, YGPercent(10));
YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPx(5));
YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(5));
YGNodeStyleSetMargin(root_child0, YGEdgeRight, YGPx(5));
YGNodeStyleSetMargin(root_child0, YGEdgeBottom, YGPx(5));
YGNodeStyleSetPadding(root_child0, YGEdgeLeft, YGPx(3));
YGNodeStyleSetPadding(root_child0, YGEdgeTop, YGPx(3));
YGNodeStyleSetPadding(root_child0, YGEdgeRight, YGPx(3));
YGNodeStyleSetPadding(root_child0, YGEdgeBottom, YGPx(3));
YGNodeStyleSetMinWidth(root_child0, YGPercent(60));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child0_child0 = YGNodeNew();
YGNodeStyleSetMarginWithUnit(root_child0_child0, YGEdgeLeft, YGPx(5));
YGNodeStyleSetMarginWithUnit(root_child0_child0, YGEdgeTop, YGPx(5));
YGNodeStyleSetMarginWithUnit(root_child0_child0, YGEdgeRight, YGPx(5));
YGNodeStyleSetMarginWithUnit(root_child0_child0, YGEdgeBottom, YGPx(5));
YGNodeStyleSetPaddingWithUnit(root_child0_child0, YGEdgeLeft, YGPercent(3));
YGNodeStyleSetPaddingWithUnit(root_child0_child0, YGEdgeTop, YGPercent(3));
YGNodeStyleSetPaddingWithUnit(root_child0_child0, YGEdgeRight, YGPercent(3));
YGNodeStyleSetPaddingWithUnit(root_child0_child0, YGEdgeBottom, YGPercent(3));
YGNodeStyleSetWidthWithUnit(root_child0_child0, YGPercent(50));
YGNodeStyleSetMargin(root_child0_child0, YGEdgeLeft, YGPx(5));
YGNodeStyleSetMargin(root_child0_child0, YGEdgeTop, YGPx(5));
YGNodeStyleSetMargin(root_child0_child0, YGEdgeRight, YGPx(5));
YGNodeStyleSetMargin(root_child0_child0, YGEdgeBottom, YGPx(5));
YGNodeStyleSetPadding(root_child0_child0, YGEdgeLeft, YGPercent(3));
YGNodeStyleSetPadding(root_child0_child0, YGEdgeTop, YGPercent(3));
YGNodeStyleSetPadding(root_child0_child0, YGEdgeRight, YGPercent(3));
YGNodeStyleSetPadding(root_child0_child0, YGEdgeBottom, YGPercent(3));
YGNodeStyleSetWidth(root_child0_child0, YGPercent(50));
YGNodeInsertChild(root_child0, root_child0_child0, 0);
const YGNodeRef root_child0_child0_child0 = YGNodeNew();
YGNodeStyleSetMarginWithUnit(root_child0_child0_child0, YGEdgeLeft, YGPercent(5));
YGNodeStyleSetMarginWithUnit(root_child0_child0_child0, YGEdgeTop, YGPercent(5));
YGNodeStyleSetMarginWithUnit(root_child0_child0_child0, YGEdgeRight, YGPercent(5));
YGNodeStyleSetMarginWithUnit(root_child0_child0_child0, YGEdgeBottom, YGPercent(5));
YGNodeStyleSetPaddingWithUnit(root_child0_child0_child0, YGEdgeLeft, YGPx(3));
YGNodeStyleSetPaddingWithUnit(root_child0_child0_child0, YGEdgeTop, YGPx(3));
YGNodeStyleSetPaddingWithUnit(root_child0_child0_child0, YGEdgeRight, YGPx(3));
YGNodeStyleSetPaddingWithUnit(root_child0_child0_child0, YGEdgeBottom, YGPx(3));
YGNodeStyleSetWidthWithUnit(root_child0_child0_child0, YGPercent(45));
YGNodeStyleSetMargin(root_child0_child0_child0, YGEdgeLeft, YGPercent(5));
YGNodeStyleSetMargin(root_child0_child0_child0, YGEdgeTop, YGPercent(5));
YGNodeStyleSetMargin(root_child0_child0_child0, YGEdgeRight, YGPercent(5));
YGNodeStyleSetMargin(root_child0_child0_child0, YGEdgeBottom, YGPercent(5));
YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeLeft, YGPx(3));
YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeTop, YGPx(3));
YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeRight, YGPx(3));
YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeBottom, YGPx(3));
YGNodeStyleSetWidth(root_child0_child0_child0, YGPercent(45));
YGNodeInsertChild(root_child0_child0, root_child0_child0_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 4);
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(15));
YGNodeStyleSetMinWidthWithUnit(root_child1, YGPercent(20));
YGNodeStyleSetFlexBasis(root_child1, YGPercent(15));
YGNodeStyleSetMinWidth(root_child1, YGPercent(20));
YGNodeInsertChild(root, root_child1, 1);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -763,20 +763,20 @@ TEST(YogaTest, percentage_margin_should_calculate_based_only_on_width) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeLeft, YGPercent(10));
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeTop, YGPercent(10));
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeRight, YGPercent(10));
YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeBottom, YGPercent(10));
YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPercent(10));
YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPercent(10));
YGNodeStyleSetMargin(root_child0, YGEdgeRight, YGPercent(10));
YGNodeStyleSetMargin(root_child0, YGEdgeBottom, YGPercent(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child0_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0_child0, YGPx(10));
YGNodeInsertChild(root_child0, root_child0_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -821,20 +821,20 @@ TEST(YogaTest, percentage_padding_should_calculate_based_only_on_width) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeLeft, YGPercent(10));
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeTop, YGPercent(10));
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeRight, YGPercent(10));
YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeBottom, YGPercent(10));
YGNodeStyleSetPadding(root_child0, YGEdgeLeft, YGPercent(10));
YGNodeStyleSetPadding(root_child0, YGEdgeTop, YGPercent(10));
YGNodeStyleSetPadding(root_child0, YGEdgeRight, YGPercent(10));
YGNodeStyleSetPadding(root_child0, YGEdgeBottom, YGPercent(10));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child0_child0 = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root_child0_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(10));
YGNodeStyleSetWidth(root_child0_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0_child0, YGPx(10));
YGNodeInsertChild(root_child0, root_child0_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -879,15 +879,15 @@ TEST(YogaTest, percentage_absolute_position) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(200));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(200));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute);
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeLeft, YGPercent(30));
YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPercent(10));
YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10));
YGNodeStyleSetPosition(root_child0, YGEdgeLeft, YGPercent(30));
YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPercent(10));
YGNodeStyleSetWidth(root_child0, YGPx(10));
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

4
tests/YGRelayoutTest.cpp
View File

@@ -16,8 +16,8 @@ TEST(YogaTest, dont_cache_computed_flex_basis_between_layouts) {
const YGNodeRef root = YGNodeNew();
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetHeight(root_child0, 10);
YGNodeStyleSetFlexBasis(root_child0, 20);
YGNodeStyleSetHeight(root_child0, YGPx(10));
YGNodeStyleSetFlexBasis(root_child0, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, 100, YGUndefined, YGDirectionLTR);

118
tests/YGRoundingTest.cpp
View File

@@ -17,8 +17,8 @@ TEST(YogaTest, rounding_flex_basis_flex_grow_row_width_of_100) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
@@ -85,8 +85,8 @@ TEST(YogaTest, rounding_flex_basis_flex_grow_row_prime_number_width) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(113));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(113));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
@@ -181,20 +181,20 @@ TEST(YogaTest, rounding_flex_basis_flex_shrink_row) {
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetWidthWithUnit(root, YGPx(101));
YGNodeStyleSetHeightWithUnit(root, YGPx(100));
YGNodeStyleSetWidth(root, YGPx(101));
YGNodeStyleSetHeight(root, YGPx(100));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexShrink(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(100));
YGNodeStyleSetFlexBasis(root_child0, YGPx(100));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPx(25));
YGNodeStyleSetFlexBasis(root_child1, YGPx(25));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetFlexBasisWithUnit(root_child2, YGPx(25));
YGNodeStyleSetFlexBasis(root_child2, YGPx(25));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -249,23 +249,23 @@ TEST(YogaTest, rounding_flex_basis_overrides_main_size) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(113));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(113));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20));
YGNodeStyleSetFlexBasis(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 1);
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child2, 1);
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -320,23 +320,23 @@ TEST(YogaTest, rounding_total_fractial) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(87.4f));
YGNodeStyleSetHeightWithUnit(root, YGPx(113.4f));
YGNodeStyleSetWidth(root, YGPx(87.4f));
YGNodeStyleSetHeight(root, YGPx(113.4f));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 0.7f);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50.3f));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20.3f));
YGNodeStyleSetFlexBasis(root_child0, YGPx(50.3f));
YGNodeStyleSetHeight(root_child0, YGPx(20.3f));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 1.6f);
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child2, 1.1f);
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10.7f));
YGNodeStyleSetHeight(root_child2, YGPx(10.7f));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -391,37 +391,37 @@ TEST(YogaTest, rounding_total_fractial_nested) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(87.4f));
YGNodeStyleSetHeightWithUnit(root, YGPx(113.4f));
YGNodeStyleSetWidth(root, YGPx(87.4f));
YGNodeStyleSetHeight(root, YGPx(113.4f));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 0.7f);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50.3f));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20.3f));
YGNodeStyleSetFlexBasis(root_child0, YGPx(50.3f));
YGNodeStyleSetHeight(root_child0, YGPx(20.3f));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child0_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0_child0, YGPx(0.3f));
YGNodeStyleSetPositionWithUnit(root_child0_child0, YGEdgeBottom, YGPx(13.3f));
YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(9.9f));
YGNodeStyleSetFlexBasis(root_child0_child0, YGPx(0.3f));
YGNodeStyleSetPosition(root_child0_child0, YGEdgeBottom, YGPx(13.3f));
YGNodeStyleSetHeight(root_child0_child0, YGPx(9.9f));
YGNodeInsertChild(root_child0, root_child0_child0, 0);
const YGNodeRef root_child0_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0_child1, 4);
YGNodeStyleSetFlexBasisWithUnit(root_child0_child1, YGPx(0.3f));
YGNodeStyleSetPositionWithUnit(root_child0_child1, YGEdgeTop, YGPx(13.3f));
YGNodeStyleSetHeightWithUnit(root_child0_child1, YGPx(1.1f));
YGNodeStyleSetFlexBasis(root_child0_child1, YGPx(0.3f));
YGNodeStyleSetPosition(root_child0_child1, YGEdgeTop, YGPx(13.3f));
YGNodeStyleSetHeight(root_child0_child1, YGPx(1.1f));
YGNodeInsertChild(root_child0, root_child0_child1, 1);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 1.6f);
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child2, 1.1f);
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10.7f));
YGNodeStyleSetHeight(root_child2, YGPx(10.7f));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -496,23 +496,23 @@ TEST(YogaTest, rounding_fractial_input_1) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(113.4f));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(113.4f));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20));
YGNodeStyleSetFlexBasis(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 1);
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child2, 1);
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -567,23 +567,23 @@ TEST(YogaTest, rounding_fractial_input_2) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(113.6f));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(113.6f));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20));
YGNodeStyleSetFlexBasis(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 1);
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child2, 1);
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -638,24 +638,24 @@ TEST(YogaTest, rounding_fractial_input_3) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetPositionWithUnit(root, YGEdgeTop, YGPx(0.3f));
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(113.4f));
YGNodeStyleSetPosition(root, YGEdgeTop, YGPx(0.3f));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(113.4f));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20));
YGNodeStyleSetFlexBasis(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 1);
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child2, 1);
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
@@ -710,24 +710,24 @@ TEST(YogaTest, rounding_fractial_input_4) {
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true);
const YGNodeRef root = YGNodeNew();
YGNodeStyleSetPositionWithUnit(root, YGEdgeTop, YGPx(0.7f));
YGNodeStyleSetWidthWithUnit(root, YGPx(100));
YGNodeStyleSetHeightWithUnit(root, YGPx(113.4f));
YGNodeStyleSetPosition(root, YGEdgeTop, YGPx(0.7f));
YGNodeStyleSetWidth(root, YGPx(100));
YGNodeStyleSetHeight(root, YGPx(113.4f));
const YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50));
YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20));
YGNodeStyleSetFlexBasis(root_child0, YGPx(50));
YGNodeStyleSetHeight(root_child0, YGPx(20));
YGNodeInsertChild(root, root_child0, 0);
const YGNodeRef root_child1 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child1, 1);
YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10));
YGNodeStyleSetHeight(root_child1, YGPx(10));
YGNodeInsertChild(root, root_child1, 1);
const YGNodeRef root_child2 = YGNodeNew();
YGNodeStyleSetFlexGrow(root_child2, 1);
YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10));
YGNodeStyleSetHeight(root_child2, YGPx(10));
YGNodeInsertChild(root, root_child2, 2);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);

273
yoga/Yoga.c
View File

@@ -113,6 +113,12 @@ YGCalloc gYGCalloc = &calloc;
YGRealloc gYGRealloc = &realloc;
YGFree gYGFree = &free;
static YGValue YGValueUndefined = {
.value = YGUndefined,
.defined = false,
.unit = YGUnitPixel
};
#ifdef ANDROID
#include <android/log.h>
static int YGAndroidLog(YGLogLevel level, const char *format, va_list args) {
@@ -161,39 +167,35 @@ static inline YGValue YGComputedEdgeValue(const YGValue edges[YGEdgeCount],
const float defaultValue) {
YG_ASSERT(edge <= YGEdgeEnd, "Cannot get computed value of multi-edge shorthands");
if (!YGValueIsUndefined(edges[edge])) {
if (edges[edge].defined) {
return edges[edge];
}
if ((edge == YGEdgeTop || edge == YGEdgeBottom) && !YGValueIsUndefined(edges[YGEdgeVertical])) {
if ((edge == YGEdgeTop || edge == YGEdgeBottom) && edges[YGEdgeVertical].defined) {
return edges[YGEdgeVertical];
}
if ((edge == YGEdgeLeft || edge == YGEdgeRight || edge == YGEdgeStart || edge == YGEdgeEnd) &&
!YGValueIsUndefined(edges[YGEdgeHorizontal])) {
edges[YGEdgeHorizontal].defined) {
emilsjolander commented 2016-12-18 22:21:08 -08:00 (Migrated from github.com)
Review
Copy Link

return YGValue {
.value = ...,
.defined = ...,
.unit = ...,
};

return YGValue { .value = ..., .defined = ..., .unit = ..., };
emilsjolander commented 2016-12-18 22:27:26 -08:00 (Migrated from github.com)
Review
Copy Link

YGValueToFloat is not very descriptive of what the function does. I would prefer YGValueResolve or something similar. What do you think?

`YGValueToFloat` is not very descriptive of what the function does. I would prefer `YGValueResolve` or something similar. What do you think?
woehrl01 commented 2016-12-18 22:58:07 -08:00 (Migrated from github.com)
Review
Copy Link

Please don't let me use this syntax here and at the other spots. Visual Studio (at least VS13 which I use) doesn't recognize this syntax, which would need me to change this one everytime I need to compile. (thats the reason I missed some tests at first)

Please don't let me use this syntax here and at the other spots. Visual Studio (at least VS13 which I use) doesn't recognize this syntax, which would need me to change this one everytime I need to compile. (thats the reason I missed some tests at first)
woehrl01 commented 2016-12-18 22:58:19 -08:00 (Migrated from github.com)
Review
Copy Link

sounds good!

sounds good!
emilsjolander commented 2016-12-18 23:12:57 -08:00 (Migrated from github.com)
Review
Copy Link

VS15 has support for this syntax and it is used throughout the project so i suggest upgrading. I would prefer it and it is part of C99. Is there a reason you are using a old VS build? if there are legit usages for old VS then I would be OK with leaving as is.

VS15 has support for this syntax and it is used throughout the project so i suggest upgrading. I would prefer it and it is part of C99. Is there a reason you are using a old VS build? if there are legit usages for old VS then I would be OK with leaving as is.
woehrl01 commented 2016-12-18 23:42:19 -08:00 (Migrated from github.com)
Review
Copy Link

none, except licence. If VS15 supports this I'm fine, making this change.

none, except licence. If VS15 supports this I'm fine, making this change.
emilsjolander commented 2016-12-18 23:46:32 -08:00 (Migrated from github.com)
Review
Copy Link

I think it does from searching google :p please double check yourself

I think it does from searching google :p please double check yourself
woehrl01 commented 2016-12-19 10:16:53 -08:00 (Migrated from github.com)
Review
Copy Link

sorry, just downloaded VS15 community and I can't get it to compile with this syntax 😞

sorry, just downloaded VS15 community and I can't get it to compile with this syntax 😞
woehrl01 commented 2016-12-19 10:28:56 -08:00 (Migrated from github.com)
Review
Copy Link

ups, got it to work, just can't return it at the same time. 😕

ups, got it to work, just can't return it at the same time. 😕
return edges[YGEdgeHorizontal];
}
if (!YGValueIsUndefined(edges[YGEdgeAll])) {
if (edges[YGEdgeAll].defined) {
return edges[YGEdgeAll];
}
if (edge == YGEdgeStart || edge == YGEdgeEnd) {
YGValue result;
result.value = YGUndefined;
result.defined = false;
result.unit = YGUnitPixel;
return result;
return YGValueUndefined;
}
YGValue result;
result.value = defaultValue;
result.defined = (defaultValue < 0 || defaultValue >= 0); /* is faster than a nan function call and enough at this point */
result.unit = YGUnitPixel;
return result;
YGValue result;
result.value = defaultValue;
result.defined = (defaultValue < 0 || defaultValue >= 0); /* is faster than a nan function call and enough at this point */
result.unit = YGUnitPixel;
return result;
}
static inline float YGValueToFloat(const YGValue unit, const float parentSize) {
static inline float YGValueResolve(const YGValue unit, const float parentSize) {
if (unit.unit == YGUnitPixel){
return unit.value;
} else {
@@ -223,40 +225,20 @@ static void YGNodeInit(const YGNodeRef node) {
node->style.overflow = YGOverflowVisible;
// Some of the fields default to undefined and not 0
node->style.dimensions[YGDimensionWidth].value = YGUndefined;
node->style.dimensions[YGDimensionWidth].defined = false;
node->style.dimensions[YGDimensionWidth].unit = YGUnitPixel;
node->style.dimensions[YGDimensionHeight].value = YGUndefined;
node->style.dimensions[YGDimensionHeight].defined = false;
node->style.dimensions[YGDimensionHeight].unit = YGUnitPixel;
node->style.dimensions[YGDimensionWidth] = YGValueUndefined;
node->style.dimensions[YGDimensionHeight] = YGValueUndefined;
node->style.minDimensions[YGDimensionWidth].value = YGUndefined;
node->style.minDimensions[YGDimensionWidth].defined = false;
node->style.minDimensions[YGDimensionWidth].unit = YGUnitPixel;
node->style.minDimensions[YGDimensionHeight].value = YGUndefined;
node->style.minDimensions[YGDimensionHeight].defined = false;
node->style.minDimensions[YGDimensionHeight].unit = YGUnitPixel;
node->style.minDimensions[YGDimensionWidth] = YGValueUndefined;
node->style.minDimensions[YGDimensionHeight] = YGValueUndefined;
node->style.maxDimensions[YGDimensionWidth].value = YGUndefined;
node->style.maxDimensions[YGDimensionWidth].defined = false;
node->style.maxDimensions[YGDimensionWidth].unit = YGUnitPixel;
node->style.maxDimensions[YGDimensionHeight].value = YGUndefined;
node->style.maxDimensions[YGDimensionHeight].defined = false;
node->style.maxDimensions[YGDimensionHeight].unit = YGUnitPixel;
node->style.maxDimensions[YGDimensionWidth] = YGValueUndefined;
node->style.maxDimensions[YGDimensionHeight] = YGValueUndefined;
for (YGEdge edge = YGEdgeLeft; edge < YGEdgeCount; edge++) {
node->style.position[edge].value = YGUndefined;
node->style.position[edge].defined = false;
node->style.position[edge].unit = YGUnitPixel;
node->style.margin[edge].value = YGUndefined;
node->style.margin[edge].defined = false;
node->style.margin[edge].unit = YGUnitPixel;
node->style.padding[edge].value = YGUndefined;
node->style.padding[edge].defined = false;
node->style.padding[edge].unit = YGUnitPixel;
node->style.border[edge].value = YGUndefined;
node->style.border[edge].defined = false;
node->style.border[edge].unit = YGUnitPixel;
node->style.position[edge] = YGValueUndefined;
node->style.margin[edge] = YGValueUndefined;
node->style.padding[edge] = YGValueUndefined;
node->style.border[edge] = YGValueUndefined;
}
node->style.aspectRatio = YGUndefined;
@@ -280,19 +262,19 @@ static void YGNodeInit(const YGNodeRef node) {
int32_t gNodeInstanceCount = 0;
YGValue YGPx(const float value){
YGValue result;
result.value = value;
result.defined = !YGFloatIsUndefined(value);
result.unit = YGUnitPixel;
return result;
YGValue result;
result.value = value;
result.defined = !YGFloatIsUndefined(value);
result.unit = YGUnitPixel;
return result;
}
YGValue YGPercent(const float value){
YGValue result;
result.value = value;
result.defined = !YGFloatIsUndefined(value);
result.unit = YGUnitPercent;
return result;
YGValue result;
result.value = value;
result.defined = !YGFloatIsUndefined(value);
result.unit = YGUnitPercent;
return result;
}
emilsjolander commented 2016-12-18 22:22:23 -08:00 (Migrated from github.com)
Review
Copy Link

return YGValue { ... };

return YGValue { ... };
emilsjolander commented 2016-12-18 22:22:29 -08:00 (Migrated from github.com)
Review
Copy Link

return YGValue { ... };

return YGValue { ... };
YGNodeRef YGNodeNew(void) {
@@ -429,18 +411,8 @@ inline float YGNodeStyleGetFlexShrink(const YGNodeRef node) {
return 0;
}
inline float YGNodeStyleGetFlexBasis(const YGNodeRef node) {
if (!YGValueIsUndefined(node->style.flexBasis)) {
return node->style.flexBasis.value;
}
if (!YGFloatIsUndefined(node->style.flex)) {
return node->style.flex > 0 ? 0 : YGUndefined;
}
return YGUndefined;
}
inline YGValue YGNodeStyleGetFlexBasisWithUnit(const YGNodeRef node) {
if (!YGValueIsUndefined(node->style.flexBasis)) {
inline YGValue YGNodeStyleGetFlexBasis(const YGNodeRef node) {
if (node->style.flexBasis.defined) {
return node->style.flexBasis;
}
if (!YGFloatIsUndefined(node->style.flex)) {
@@ -474,21 +446,13 @@ void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) {
}
#define YG_NODE_STYLE_PROPERTY_SETTER_UNIT_IMPL(type, name, paramName, instanceName) \
void YGNodeStyleSet##name##WithUnit(const YGNodeRef node, const type paramName) { \
void YGNodeStyleSet##name##(const YGNodeRef node, const type paramName) { \
if (node->style.instanceName.value != paramName.value || node->style.instanceName.unit != paramName.unit) { \
node->style.instanceName.value = paramName.value; \
node->style.instanceName.defined = !YGFloatIsUndefined(paramName.value); \
node->style.instanceName.unit = paramName.unit; \
YGNodeMarkDirtyInternal(node); \
} \
} \
void YGNodeStyleSet##name(const YGNodeRef node, const float paramName) { \
if (node->style.instanceName.value != paramName || node->style.instanceName.unit != YGUnitPixel) { \
node->style.instanceName.value = paramName; \
node->style.instanceName.defined = !YGFloatIsUndefined(paramName); \
node->style.instanceName.unit = YGUnitPixel; \
YGNodeMarkDirtyInternal(node); \
} \
} \
}
#define YG_NODE_STYLE_PROPERTY_IMPL(type, name, paramName, instanceName) \
@@ -501,39 +465,24 @@ void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) {
#define YG_NODE_STYLE_PROPERTY_UNIT_IMPL(type, name, paramName, instanceName) \
YG_NODE_STYLE_PROPERTY_SETTER_UNIT_IMPL(type, name, paramName, instanceName) \
\
float YGNodeStyleGet##name(const YGNodeRef node) { \
return node->style.instanceName.value; \
} \
type YGNodeStyleGet##name##WithUnit(const YGNodeRef node) { \
type YGNodeStyleGet##name##(const YGNodeRef node) { \
return node->style.instanceName; \
}
#define YG_NODE_STYLE_EDGE_PROPERTY_UNIT_IMPL(type, name, paramName, instanceName, defaultValue) \
void YGNodeStyleSet##name##WithUnit(const YGNodeRef node, const YGEdge edge, const type paramName) { \
void YGNodeStyleSet##name##(const YGNodeRef node, const YGEdge edge, const type paramName) { \
if (node->style.instanceName[edge].value != paramName.value || node->style.instanceName[edge].unit != paramName.unit ) { \
node->style.instanceName[edge].value = paramName.value; \
node->style.instanceName[edge].defined = !YGFloatIsUndefined(paramName.value); \
node->style.instanceName[edge].unit = paramName.unit; \
YGNodeMarkDirtyInternal(node); \
} \
} \
} \
\
void YGNodeStyleSet##name(const YGNodeRef node, const YGEdge edge, const float paramName) { \
if (node->style.instanceName[edge].value != paramName || node->style.instanceName[edge].unit != YGUnitPixel ) { \
node->style.instanceName[edge].value = paramName; \
node->style.instanceName[edge].defined = !YGFloatIsUndefined(paramName); \
node->style.instanceName[edge].unit = YGUnitPixel; \
YGNodeMarkDirtyInternal(node); \
} \
} \
\
type YGNodeStyleGet##name##WithUnit(const YGNodeRef node, const YGEdge edge) { \
type YGNodeStyleGet##name##(const YGNodeRef node, const YGEdge edge) { \
return YGComputedEdgeValue(node->style.instanceName, edge, defaultValue); \
} \
\
float YGNodeStyleGet##name(const YGNodeRef node, const YGEdge edge) { \
return YGComputedEdgeValue(node->style.instanceName, edge, defaultValue).value; \
}
#define YG_NODE_STYLE_EDGE_PROPERTY_IMPL(type, name, paramName, instanceName, defaultValue) \
void YGNodeStyleSet##name(const YGNodeRef node, const YGEdge edge, const float paramName) { \
@@ -612,17 +561,13 @@ inline bool YGFloatIsUndefined(const float value) {
return isnan(value);
}
inline bool YGValueIsUndefined(const YGValue value) {
return !value.defined;
}
static inline bool YGValueEqual(const YGValue a, const YGValue b) {
if (a.unit != b.unit){
return false;
}
if (YGValueIsUndefined(a)) {
return YGValueIsUndefined(b);
if (!a.defined) {
return !b.defined;
}
return fabs(a.value - b.value) < 0.0001;
}
@@ -653,7 +598,7 @@ static void YGPrintNumberIfNotUndefinedf(const char *str, const float number) {
}
static void YGPrintNumberIfNotUndefined(const char *str, const YGValue number) {
if (!YGValueIsUndefined(number)) {
if (number.defined) {
YGLog(YGLogLevelDebug, "%s: %g%s, ", str, number, number.unit == YGUnitPixel ? "px" : "%");
}
emilsjolander commented 2016-12-18 22:24:58 -08:00 (Migrated from github.com)
Review
Copy Link

just check for .defined. this function just makes it more verbose.

just check for `.defined`. this function just makes it more verbose.
}
@@ -731,7 +676,7 @@ static void YGNodePrintInternal(const YGNodeRef node,
YGPrintNumberIfNotUndefinedf("flexGrow", YGNodeStyleGetFlexGrow(node));
YGPrintNumberIfNotUndefinedf("flexShrink", YGNodeStyleGetFlexShrink(node));
YGPrintNumberIfNotUndefined("flexBasis", YGNodeStyleGetFlexBasisWithUnit(node));
YGPrintNumberIfNotUndefined("flexBasis", YGNodeStyleGetFlexBasis(node));
if (node->style.overflow == YGOverflowHidden) {
YGLog(YGLogLevelDebug, "overflow: 'hidden', ");
@@ -859,41 +804,41 @@ static inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection)
}
static inline float YGNodeLeadingMargin(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) {
if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.margin[YGEdgeStart])) {
return YGValueToFloat(node->style.margin[YGEdgeStart], widthSize);
if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeStart].defined) {
return YGValueResolve(node->style.margin[YGEdgeStart], widthSize);
}
return YGValueToFloat(YGComputedEdgeValue(node->style.margin, leading[axis], 0), widthSize);
return YGValueResolve(YGComputedEdgeValue(node->style.margin, leading[axis], 0), widthSize);
}
static float YGNodeTrailingMargin(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) {
if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.margin[YGEdgeEnd])) {
return YGValueToFloat(node->style.margin[YGEdgeEnd], widthSize);
if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeEnd].defined) {
return YGValueResolve(node->style.margin[YGEdgeEnd], widthSize);
}
return YGValueToFloat(YGComputedEdgeValue(node->style.margin, trailing[axis], 0), widthSize);
return YGValueResolve(YGComputedEdgeValue(node->style.margin, trailing[axis], 0), widthSize);
}
static float YGNodeLeadingPadding(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) {
if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.padding[YGEdgeStart]) &&
YGValueToFloat(node->style.padding[YGEdgeStart], widthSize) >= 0) {
return YGValueToFloat(node->style.padding[YGEdgeStart], widthSize);
if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeStart].defined &&
YGValueResolve(node->style.padding[YGEdgeStart], widthSize) >= 0) {
return YGValueResolve(node->style.padding[YGEdgeStart], widthSize);
}
return fmaxf(YGValueToFloat(YGComputedEdgeValue(node->style.padding, leading[axis], 0), widthSize), 0);
return fmaxf(YGValueResolve(YGComputedEdgeValue(node->style.padding, leading[axis], 0), widthSize), 0);
}
static float YGNodeTrailingPadding(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) {
if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.padding[YGEdgeEnd]) &&
YGValueToFloat(node->style.padding[YGEdgeEnd], widthSize) >= 0) {
return YGValueToFloat(node->style.padding[YGEdgeEnd], widthSize);
if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeEnd].defined &&
YGValueResolve(node->style.padding[YGEdgeEnd], widthSize) >= 0) {
return YGValueResolve(node->style.padding[YGEdgeEnd], widthSize);
}
return fmaxf(YGValueToFloat(YGComputedEdgeValue(node->style.padding, trailing[axis], 0), widthSize), 0);
return fmaxf(YGValueResolve(YGComputedEdgeValue(node->style.padding, trailing[axis], 0), widthSize), 0);
}
static float YGNodeLeadingBorder(const YGNodeRef node, const YGFlexDirection axis) {
if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.border[YGEdgeStart]) &&
if (YGFlexDirectionIsRow(axis) && node->style.border[YGEdgeStart].defined &&
node->style.border[YGEdgeStart].value >= 0) {
return node->style.border[YGEdgeStart].value;
}
@@ -902,7 +847,7 @@ static float YGNodeLeadingBorder(const YGNodeRef node, const YGFlexDirection axi
}
static float YGNodeTrailingBorder(const YGNodeRef node, const YGFlexDirection axis) {
if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.border[YGEdgeEnd]) &&
if (YGFlexDirectionIsRow(axis) && node->style.border[YGEdgeEnd].defined &&
node->style.border[YGEdgeEnd].value >= 0) {
return node->style.border[YGEdgeEnd].value;
}
@@ -974,7 +919,7 @@ static inline float YGNodeDimWithMargin(const YGNodeRef node, const YGFlexDirect
static inline bool YGNodeIsStyleDimDefined(const YGNodeRef node, const YGFlexDirection axis) {
const YGValue value = node->style.dimensions[dim[axis]];
return !YGValueIsUndefined(value) && value.value >= 0.0;
return value.defined && value.value >= 0.0;
}
static inline bool YGNodeIsLayoutDimDefined(const YGNodeRef node, const YGFlexDirection axis) {
@@ -984,46 +929,44 @@ static inline bool YGNodeIsLayoutDimDefined(const YGNodeRef node, const YGFlexDi
static inline bool YGNodeIsLeadingPosDefined(const YGNodeRef node, const YGFlexDirection axis) {
return (YGFlexDirectionIsRow(axis) &&
!YGValueIsUndefined(
YGComputedEdgeValue(node->style.position, YGEdgeStart, YGUndefined))) ||
!YGValueIsUndefined(YGComputedEdgeValue(node->style.position, leading[axis], YGUndefined));
YGComputedEdgeValue(node->style.position, YGEdgeStart, YGUndefined).defined) ||
YGComputedEdgeValue(node->style.position, leading[axis], YGUndefined).defined;
}
static inline bool YGNodeIsTrailingPosDefined(const YGNodeRef node, const YGFlexDirection axis) {
return (YGFlexDirectionIsRow(axis) &&
!YGValueIsUndefined(YGComputedEdgeValue(node->style.position, YGEdgeEnd, YGUndefined))) ||
!YGValueIsUndefined(
YGComputedEdgeValue(node->style.position, trailing[axis], YGUndefined));
YGComputedEdgeValue(node->style.position, YGEdgeEnd, YGUndefined).defined) ||
YGComputedEdgeValue(node->style.position, trailing[axis], YGUndefined).defined;
}
static float YGNodeLeadingPosition(const YGNodeRef node, const YGFlexDirection axis, const float axisSize) {
if (YGFlexDirectionIsRow(axis)) {
const YGValue leadingPosition =
YGComputedEdgeValue(node->style.position, YGEdgeStart, YGUndefined);
if (!YGValueIsUndefined(leadingPosition)) {
return YGValueToFloat(leadingPosition, axisSize);
if (leadingPosition.defined) {
return YGValueResolve(leadingPosition, axisSize);
}
}
const YGValue leadingPosition =
YGComputedEdgeValue(node->style.position, leading[axis], YGUndefined);
return YGValueIsUndefined(leadingPosition) ? 0 : YGValueToFloat(leadingPosition, axisSize);
return !leadingPosition.defined ? 0 : YGValueResolve(leadingPosition, axisSize);
}
static float YGNodeTrailingPosition(const YGNodeRef node, const YGFlexDirection axis, const float axisSize) {
if (YGFlexDirectionIsRow(axis)) {
const YGValue trailingPosition =
YGComputedEdgeValue(node->style.position, YGEdgeEnd, YGUndefined);
if (!YGValueIsUndefined(trailingPosition)) {
return YGValueToFloat(trailingPosition, axisSize);
if (trailingPosition.defined) {
return YGValueResolve(trailingPosition, axisSize);
}
}
const YGValue trailingPosition =
YGComputedEdgeValue(node->style.position, trailing[axis], YGUndefined);
return YGValueIsUndefined(trailingPosition) ? 0 : YGValueToFloat(trailingPosition, axisSize);
return !trailingPosition.defined ? 0 : YGValueResolve(trailingPosition, axisSize);
}
static float YGNodeBoundAxisWithinMinAndMax(const YGNodeRef node,
@@ -1033,11 +976,11 @@ static float YGNodeBoundAxisWithinMinAndMax(const YGNodeRef node,
float max = YGUndefined;
if (YGFlexDirectionIsColumn(axis)) {
min = YGValueToFloat(node->style.minDimensions[YGDimensionHeight], axisSize);
max = YGValueToFloat(node->style.maxDimensions[YGDimensionHeight], axisSize);
min = YGValueResolve(node->style.minDimensions[YGDimensionHeight], axisSize);
max = YGValueResolve(node->style.maxDimensions[YGDimensionHeight], axisSize);
} else if (YGFlexDirectionIsRow(axis)) {
min = YGValueToFloat(node->style.minDimensions[YGDimensionWidth], axisSize);
max = YGValueToFloat(node->style.maxDimensions[YGDimensionWidth], axisSize);
min = YGValueResolve(node->style.minDimensions[YGDimensionWidth], axisSize);
max = YGValueResolve(node->style.maxDimensions[YGDimensionWidth], axisSize);
}
float boundValue = value;
@@ -1133,23 +1076,23 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
const bool isRowStyleDimDefined = YGNodeIsStyleDimDefined(child, YGFlexDirectionRow);
const bool isColumnStyleDimDefined = YGNodeIsStyleDimDefined(child, YGFlexDirectionColumn);
if (!YGValueIsUndefined(YGNodeStyleGetFlexBasisWithUnit(child)) &&
if (YGNodeStyleGetFlexBasis(child).defined &&
!YGFloatIsUndefined(mainAxisSize)) {
if (YGFloatIsUndefined(child->layout.computedFlexBasis) ||
(YGIsExperimentalFeatureEnabled(YGExperimentalFeatureWebFlexBasis) &&
child->layout.computedFlexBasisGeneration != gCurrentGenerationCount)) {
child->layout.computedFlexBasis =
fmaxf(YGValueToFloat(YGNodeStyleGetFlexBasisWithUnit(child), mainAxisParentSize), YGNodePaddingAndBorderForAxis(child, mainAxis, parentWidth));
fmaxf(YGValueResolve(YGNodeStyleGetFlexBasis(child), mainAxisParentSize), YGNodePaddingAndBorderForAxis(child, mainAxis, parentWidth));
}
} else if (isMainAxisRow && isRowStyleDimDefined) {
// The width is definite, so use that as the flex basis.
child->layout.computedFlexBasis =
fmaxf(YGValueToFloat(child->style.dimensions[YGDimensionWidth], parentWidth),
fmaxf(YGValueResolve(child->style.dimensions[YGDimensionWidth], parentWidth),
YGNodePaddingAndBorderForAxis(child, YGFlexDirectionRow, parentWidth));
} else if (!isMainAxisRow && isColumnStyleDimDefined) {
// The height is definite, so use that as the flex basis.
child->layout.computedFlexBasis =
fmaxf(YGValueToFloat(child->style.dimensions[YGDimensionHeight], parentHeight),
fmaxf(YGValueResolve(child->style.dimensions[YGDimensionHeight], parentHeight),
YGNodePaddingAndBorderForAxis(child, YGFlexDirectionColumn, parentWidth));
} else {
// Compute the flex basis and hypothetical main size (i.e. the clamped
@@ -1160,12 +1103,12 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
childHeightMeasureMode = YGMeasureModeUndefined;
if (isRowStyleDimDefined) {
childWidth = YGValueToFloat(child->style.dimensions[YGDimensionWidth], parentWidth) +
childWidth = YGValueResolve(child->style.dimensions[YGDimensionWidth], parentWidth) +
YGNodeMarginForAxis(child, YGFlexDirectionRow, parentWidth);
childWidthMeasureMode = YGMeasureModeExactly;
}
if (isColumnStyleDimDefined) {
childHeight = YGValueToFloat(child->style.dimensions[YGDimensionHeight], parentHeight) +
childHeight = YGValueResolve(child->style.dimensions[YGDimensionHeight], parentHeight) +
YGNodeMarginForAxis(child, YGFlexDirectionColumn, parentWidth);
childHeightMeasureMode = YGMeasureModeExactly;
}
@@ -1216,10 +1159,10 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
}
}
YGConstrainMaxSizeForMode(YGValueToFloat(child->style.maxDimensions[YGDimensionWidth], parentWidth),
YGConstrainMaxSizeForMode(YGValueResolve(child->style.maxDimensions[YGDimensionWidth], parentWidth),
&childWidthMeasureMode,
&childWidth);
YGConstrainMaxSizeForMode(YGValueToFloat(child->style.maxDimensions[YGDimensionHeight], parentHeight),
YGConstrainMaxSizeForMode(YGValueResolve(child->style.maxDimensions[YGDimensionHeight], parentHeight),
&childHeightMeasureMode,
&childHeight);
@@ -1260,7 +1203,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node,
YGMeasureMode childHeightMeasureMode = YGMeasureModeUndefined;
if (YGNodeIsStyleDimDefined(child, YGFlexDirectionRow)) {
childWidth = YGValueToFloat(child->style.dimensions[YGDimensionWidth], width) +
childWidth = YGValueResolve(child->style.dimensions[YGDimensionWidth], width) +
YGNodeMarginForAxis(child, YGFlexDirectionRow, width);
} else {
// If the child doesn't have a specified width, compute the width based
@@ -1278,7 +1221,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node,
}
if (YGNodeIsStyleDimDefined(child, YGFlexDirectionColumn)) {
childHeight = YGValueToFloat(child->style.dimensions[YGDimensionHeight], height) +
childHeight = YGValueResolve(child->style.dimensions[YGDimensionHeight], height) +
YGNodeMarginForAxis(child, YGFlexDirectionColumn, width);
} else {
// If the child doesn't have a specified height, compute the height
@@ -1289,8 +1232,8 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node,
childHeight = node->layout.measuredDimensions[YGDimensionHeight] -
(YGNodeLeadingBorder(node, YGFlexDirectionColumn) +
YGNodeTrailingBorder(node, YGFlexDirectionColumn)) -
(YGNodeLeadingPosition(child, YGFlexDirectionColumn, width) +
YGNodeTrailingPosition(child, YGFlexDirectionColumn, width));
(YGNodeLeadingPosition(child, YGFlexDirectionColumn, height) +
YGNodeTrailingPosition(child, YGFlexDirectionColumn, height));
childHeight = YGNodeBoundAxis(child, YGFlexDirectionColumn, childHeight, height, width);
}
}
@@ -1982,7 +1925,7 @@ static void YGNodelayoutImpl(const YGNodeRef node,
childHeightMeasureMode =
YGFloatIsUndefined(childHeight) ? YGMeasureModeUndefined : YGMeasureModeAtMost;
} else {
childHeight = YGValueToFloat(currentRelativeChild->style.dimensions[YGDimensionHeight], availableInnerHeight) +
childHeight = YGValueResolve(currentRelativeChild->style.dimensions[YGDimensionHeight], availableInnerHeight) +
YGNodeMarginForAxis(currentRelativeChild, YGFlexDirectionColumn, availableInnerWidth);
childHeightMeasureMode = YGMeasureModeExactly;
}
@@ -2002,7 +1945,7 @@ static void YGNodelayoutImpl(const YGNodeRef node,
childWidthMeasureMode =
YGFloatIsUndefined(childWidth) ? YGMeasureModeUndefined : YGMeasureModeAtMost;
} else {
childWidth = YGValueToFloat(currentRelativeChild->style.dimensions[YGDimensionWidth], availableInnerWidth) +
childWidth = YGValueResolve(currentRelativeChild->style.dimensions[YGDimensionWidth], availableInnerWidth) +
YGNodeMarginForAxis(currentRelativeChild, YGFlexDirectionRow, availableInnerWidth);
childWidthMeasureMode = YGMeasureModeExactly;
}
@@ -2022,10 +1965,10 @@ static void YGNodelayoutImpl(const YGNodeRef node,
}
}
YGConstrainMaxSizeForMode(YGValueToFloat(currentRelativeChild->style.maxDimensions[YGDimensionWidth], availableInnerWidth),
YGConstrainMaxSizeForMode(YGValueResolve(currentRelativeChild->style.maxDimensions[YGDimensionWidth], availableInnerWidth),
&childWidthMeasureMode,
&childWidth);
YGConstrainMaxSizeForMode(YGValueToFloat(currentRelativeChild->style.maxDimensions[YGDimensionHeight], availableInnerHeight),
YGConstrainMaxSizeForMode(YGValueResolve(currentRelativeChild->style.maxDimensions[YGDimensionHeight], availableInnerHeight),
&childHeightMeasureMode,
&childHeight);
@@ -2065,10 +2008,10 @@ static void YGNodelayoutImpl(const YGNodeRef node,
// constraint by the min size defined for the main axis.
if (measureModeMainDim == YGMeasureModeAtMost && remainingFreeSpace > 0) {
if (!YGValueIsUndefined(node->style.minDimensions[dim[mainAxis]]) &&
YGValueToFloat(node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) >= 0) {
if (node->style.minDimensions[dim[mainAxis]].defined &&
YGValueResolve(node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) >= 0) {
remainingFreeSpace = fmaxf(0,
YGValueToFloat(node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) -
YGValueResolve(node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) -
(availableInnerMainDim - remainingFreeSpace));
} else {
remainingFreeSpace = 0;
@@ -2222,10 +2165,10 @@ static void YGNodelayoutImpl(const YGNodeRef node,
YGNodeMarginForAxis(child, YGFlexDirectionColumn, availableInnerWidth);
}
YGConstrainMaxSizeForMode(YGValueToFloat(child->style.maxDimensions[YGDimensionWidth], availableInnerWidth),
YGConstrainMaxSizeForMode(YGValueResolve(child->style.maxDimensions[YGDimensionWidth], availableInnerWidth),
&childWidthMeasureMode,
&childWidth);
YGConstrainMaxSizeForMode(YGValueToFloat(child->style.maxDimensions[YGDimensionHeight], availableInnerHeight),
YGConstrainMaxSizeForMode(YGValueResolve(child->style.maxDimensions[YGDimensionHeight], availableInnerHeight),
&childHeightMeasureMode,
&childHeight);
@@ -2763,22 +2706,22 @@ void YGNodeCalculateLayout(const YGNodeRef node,
if (!YGFloatIsUndefined(width)) {
widthMeasureMode = YGMeasureModeExactly;
} else if (YGNodeIsStyleDimDefined(node, YGFlexDirectionRow)) {
width = YGValueToFloat(node->style.dimensions[dim[YGFlexDirectionRow]], availableWidth) +
width = YGValueResolve(node->style.dimensions[dim[YGFlexDirectionRow]], availableWidth) +
YGNodeMarginForAxis(node, YGFlexDirectionRow, availableWidth);
widthMeasureMode = YGMeasureModeExactly;
} else if (YGValueToFloat(node->style.maxDimensions[YGDimensionWidth], availableWidth) >= 0.0) {
width = YGValueToFloat(node->style.maxDimensions[YGDimensionWidth], availableWidth);
} else if (YGValueResolve(node->style.maxDimensions[YGDimensionWidth], availableWidth) >= 0.0) {
width = YGValueResolve(node->style.maxDimensions[YGDimensionWidth], availableWidth);
widthMeasureMode = YGMeasureModeAtMost;
}
if (!YGFloatIsUndefined(height)) {
heightMeasureMode = YGMeasureModeExactly;
} else if (YGNodeIsStyleDimDefined(node, YGFlexDirectionColumn)) {
height = YGValueToFloat(node->style.dimensions[dim[YGFlexDirectionColumn]], availableHeight) +
height = YGValueResolve(node->style.dimensions[dim[YGFlexDirectionColumn]], availableHeight) +
YGNodeMarginForAxis(node, YGFlexDirectionColumn, availableWidth);
heightMeasureMode = YGMeasureModeExactly;
} else if (YGValueToFloat(node->style.maxDimensions[YGDimensionHeight], availableHeight) >= 0.0) {
height = YGValueToFloat(node->style.maxDimensions[YGDimensionHeight], availableHeight);
} else if (YGValueResolve(node->style.maxDimensions[YGDimensionHeight], availableHeight) >= 0.0) {
height = YGValueResolve(node->style.maxDimensions[YGDimensionHeight], availableHeight);
heightMeasureMode = YGMeasureModeAtMost;
}

14
yoga/Yoga.h
View File

@@ -38,11 +38,10 @@ typedef struct YGSize {
float height;
emilsjolander commented 2016-12-18 22:13:11 -08:00 (Migrated from github.com)
Review
Copy Link

remove empty line

remove empty line
emilsjolander commented 2016-12-18 22:13:35 -08:00 (Migrated from github.com)
Review
Copy Link

space before { (actually just run format.sh)

space before { (actually just run format.sh)
woehrl01 commented 2016-12-19 10:23:01 -08:00 (Migrated from github.com)
Review
Copy Link

I would like to do this, but setting everything up on my maschine would be a huge job. As I have no linux runtime currently available, and also no clang localy. It would be greate if you could run this, after your import, if you don't mind. Same for enum.py, currently I have no python installed. If not I'll try my best to set this up locally, could take a while (the clang environment).

I would like to do this, but setting everything up on my maschine would be a huge job. As I have no linux runtime currently available, and also no clang localy. It would be greate if you could run this, after your import, if you don't mind. Same for enum.py, currently I have no python installed. If not I'll try my best to set this up locally, could take a while (the clang environment).
emilsjolander commented 2016-12-19 11:56:48 -08:00 (Migrated from github.com)
Review
Copy Link

isDefined

isDefined
woehrl01 commented 2016-12-19 12:09:04 -08:00 (Migrated from github.com)
Review
Copy Link

great idea!

great idea!
} YGSize;
typedef struct YGValue{
typedef struct YGValue {
float value;
YGUnit unit;
bool defined;
} YGValue;
WIN_EXPORT YGValue YGPx(const float value);
@@ -93,7 +92,6 @@ WIN_EXPORT bool YGNodeIsDirty(const YGNodeRef node);
WIN_EXPORT void YGNodePrint(const YGNodeRef node, const YGPrintOptions options);
emilsjolander commented 2016-12-18 22:16:31 -08:00 (Migrated from github.com)
Review
Copy Link

No reason to have this function as we export the defined member of YGValue

No reason to have this function as we export the `defined` member of `YGValue`
WIN_EXPORT bool YGFloatIsUndefined(const float value);
WIN_EXPORT bool YGValueIsUndefined(const YGValue value);
WIN_EXPORT bool YGNodeCanUseCachedMeasurement(const YGMeasureMode widthMode,
const float width,
@@ -119,9 +117,8 @@ WIN_EXPORT void YGNodeCopyStyle(const YGNodeRef dstNode, const YGNodeRef srcNode
WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node);
emilsjolander commented 2016-12-18 22:18:49 -08:00 (Migrated from github.com)
Review
Copy Link

Let's remove the *WithUnit APIs and just use units everywhere. This makes the API smaller and more concise. Also it forces the user to think about units.

Let's remove the *WithUnit APIs and just use units everywhere. This makes the API smaller and more concise. Also it forces the user to think about units.
woehrl01 commented 2016-12-18 22:55:57 -08:00 (Migrated from github.com)
Review
Copy Link

How should we return the units in the getter? Should I use YGValue in both get + set or use (float, YGUnitPixel) in the set and return only the float in get?

How should we return the units in the getter? Should I use YGValue in both get + set or use (float, YGUnitPixel) in the set and return only the float in get?
emilsjolander commented 2016-12-18 23:09:51 -08:00 (Migrated from github.com)
Review
Copy Link

The getter should return a YGValue as well.

The getter should return a YGValue as well.
#define YG_NODE_STYLE_PROPERTY_UNIT(type, name, paramName) \
YG_NODE_STYLE_PROPERTY(float, name, paramName); \
WIN_EXPORT void YGNodeStyleSet##name##WithUnit(const YGNodeRef node, const type paramName); \
WIN_EXPORT type YGNodeStyleGet##name##WithUnit(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSet##name##(const YGNodeRef node, const type paramName); \
WIN_EXPORT type YGNodeStyleGet##name##(const YGNodeRef node);
#define YG_NODE_STYLE_EDGE_PROPERTY(type, name, paramName) \
WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node, \
@@ -130,11 +127,10 @@ WIN_EXPORT void YGNodeCopyStyle(const YGNodeRef dstNode, const YGNodeRef srcNode
WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node, const YGEdge edge);
#define YG_NODE_STYLE_EDGE_PROPERTY_UNIT(type, name, paramName) \
YG_NODE_STYLE_EDGE_PROPERTY(float, name, paramName) \
WIN_EXPORT void YGNodeStyleSet##name##WithUnit(const YGNodeRef node, \
WIN_EXPORT void YGNodeStyleSet##name##(const YGNodeRef node, \
const YGEdge edge, \
const type paramName); \
WIN_EXPORT type YGNodeStyleGet##name##WithUnit(const YGNodeRef node, const YGEdge edge);
WIN_EXPORT type YGNodeStyleGet##name##(const YGNodeRef node, const YGEdge edge);
#define YG_NODE_LAYOUT_PROPERTY(type, name) \
WIN_EXPORT type YGNodeLayoutGet##name(const YGNodeRef node);