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

Move generated Jest tests to TypeScript (#1287)

Browse Source 
Summary:
Pull Request resolved: https://github.com/facebook/yoga/pull/1287

Outputs tests as TypeScript, along with using/testing the new form of enums imported directly from the package.

We need to change how we are telling Jest which variant to run, so that tests can import enums from "yoga-layout" and have it resolve to the entrypoint which has a binary which has already been built.

Reviewed By: yungsters

Differential Revision: D45723545

fbshipit-source-id: 887d929344a78cadec159a07c643b74b76b87c6c
This commit is contained in:
Nick Gerleman
2023-05-10 22:46:39 -07:00
committed by Facebook GitHub Bot
parent e769dd97d8
commit 149849d22b
23 changed files with 2231 additions and 1878 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
gentest/gentest-javascript.js
View File

@@ -16,22 +16,31 @@ function toValueJavascript(value) {
return value;
}
function toJavascriptUpper(symbol) {
let out = '';
for (let i = 0; i < symbol.length; i++) {
const c = symbol.charAt(i);
if (c == c.toUpperCase() && i != 0 && symbol[i - 1] != symbol[i - 1].toUpperCase()) {
out += '_';
}
out += c.toUpperCase();
}
return out;
}
JavascriptEmitter.prototype = Object.create(Emitter.prototype, {
constructor:{value:JavascriptEmitter},
emitPrologue:{value:function() {}},
emitPrologue:{value:function() {
this.push('import {Yoga} from "../tools/globals";')
this.push('import {')
this.pushIndent();
this.push('Align,');
this.push('Direction,');
this.push('Display,');
this.push('Edge,');
this.push('Errata,');
this.push('ExperimentalFeature,');
this.push('FlexDirection,');
this.push('Gutter,');
this.push('Justify,');
this.push('MeasureMode,');
this.push('Overflow,');
this.push('PositionType,');
this.push('Unit,');
this.push('Wrap,');
this.popIndent();
this.push('} from \'yoga-layout\';');
this.push('');
}},
emitTestPrologue:{value:function(name, experiments, ignore) {
const testFn = ignore ? `test.skip` : 'test';
@@ -43,7 +52,7 @@ JavascriptEmitter.prototype = Object.create(Emitter.prototype, {
if (experiments.length > 0) {
for (const experiment of experiments) {
this.push('config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_' + toJavascriptUpper(experiment) + ', true);');
this.push(`config.setExperimentalFeatureEnabled(ExperimentalFeature.${experiment}, true);`);
}
this.push('');
}
@@ -88,58 +97,57 @@ JavascriptEmitter.prototype = Object.create(Emitter.prototype, {
this.push(`expect(${v1}).toBe(${v0});`);
}},
YGAlignAuto:{value:'Yoga.ALIGN_AUTO'},
YGAlignCenter:{value:'Yoga.ALIGN_CENTER'},
YGAlignFlexEnd:{value:'Yoga.ALIGN_FLEX_END'},
YGAlignFlexStart:{value:'Yoga.ALIGN_FLEX_START'},
YGAlignStretch:{value:'Yoga.ALIGN_STRETCH'},
YGAlignSpaceBetween:{value:'Yoga.ALIGN_SPACE_BETWEEN'},
YGAlignSpaceAround:{value:'Yoga.ALIGN_SPACE_AROUND'},
YGAlignBaseline:{value:'Yoga.ALIGN_BASELINE'},
YGAlignAuto:{value: 'Align.Auto'},
YGAlignCenter:{value: 'Align.Center'},
YGAlignFlexEnd:{value: 'Align.FlexEnd'},
YGAlignFlexStart:{value: 'Align.FlexStart'},
YGAlignStretch:{value: 'Align.Stretch'},
YGAlignSpaceBetween:{value: 'Align.SpaceBetween'},
YGAlignSpaceAround:{value: 'Align.SpaceAround'},
YGAlignBaseline:{value: 'Align.Baseline'},
YGDirectionInherit:{value:'Yoga.DIRECTION_INHERIT'},
YGDirectionLTR:{value:'Yoga.DIRECTION_LTR'},
YGDirectionRTL:{value:'Yoga.DIRECTION_RTL'},
YGDirectionInherit:{value: 'Direction.Inherit'},
YGDirectionLTR:{value: 'Direction.LTR'},
YGDirectionRTL:{value: 'Direction.RTL'},
YGEdgeBottom:{value:'Yoga.EDGE_BOTTOM'},
YGEdgeEnd:{value:'Yoga.EDGE_END'},
YGEdgeLeft:{value:'Yoga.EDGE_LEFT'},
YGEdgeRight:{value:'Yoga.EDGE_RIGHT'},
YGEdgeStart:{value:'Yoga.EDGE_START'},
YGEdgeTop:{value:'Yoga.EDGE_TOP'},
YGEdgeBottom:{value: 'Edge.Bottom'},
YGEdgeEnd:{value: 'Edge.End'},
YGEdgeLeft:{value: 'Edge.Left'},
YGEdgeRight:{value: 'Edge.Right'},
YGEdgeStart:{value: 'Edge.Start'},
YGEdgeTop:{value: 'Edge.Top'},
YGGutterAll:{value:'Yoga.GUTTER_ALL'},
YGGutterColumn:{value:'Yoga.GUTTER_COLUMN'},
YGGutterRow:{value:'Yoga.GUTTER_ROW'},
YGGutterAll:{value: 'Gutter.All'},
YGGutterColumn:{value: 'Gutter.Column'},
YGGutterRow:{value: 'Gutter.Row'},
YGFlexDirectionColumn:{value:'Yoga.FLEX_DIRECTION_COLUMN'},
YGFlexDirectionColumnReverse:{value:'Yoga.FLEX_DIRECTION_COLUMN_REVERSE'},
YGFlexDirectionRow:{value:'Yoga.FLEX_DIRECTION_ROW'},
YGFlexDirectionRowReverse:{value:'Yoga.FLEX_DIRECTION_ROW_REVERSE'},
YGFlexDirectionColumn:{value: 'FlexDirection.Column'},
YGFlexDirectionColumnReverse:{value: 'FlexDirection.ColumnReverse'},
YGFlexDirectionRow:{value: 'FlexDirection.Row'},
YGFlexDirectionRowReverse:{value: 'FlexDirection.RowReverse'},
YGJustifyCenter:{value:'Yoga.JUSTIFY_CENTER'},
YGJustifyFlexEnd:{value:'Yoga.JUSTIFY_FLEX_END'},
YGJustifyFlexStart:{value:'Yoga.JUSTIFY_FLEX_START'},
YGJustifySpaceAround:{value:'Yoga.JUSTIFY_SPACE_AROUND'},
YGJustifySpaceBetween:{value:'Yoga.JUSTIFY_SPACE_BETWEEN'},
YGJustifySpaceEvenly:{value:'Yoga.JUSTIFY_SPACE_EVENLY'},
YGJustifyCenter:{value: 'Justify.Center'},
YGJustifyFlexEnd:{value: 'Justify.FlexEnd'},
YGJustifyFlexStart:{value: 'Justify.FlexStart'},
YGJustifySpaceAround:{value: 'Justify.SpaceAround'},
YGJustifySpaceBetween:{value: 'Justify.SpaceBetween'},
YGJustifySpaceEvenly:{value: 'Justify.SpaceEvenly'},
YGOverflowHidden:{value:'Yoga.OVERFLOW_HIDDEN'},
YGOverflowVisible:{value:'Yoga.OVERFLOW_VISIBLE'},
YGOverflowHidden:{value: 'Overflow.Hidden'},
YGOverflowVisible:{value: 'Overflow.Visible'},
YGPositionTypeAbsolute:{value:'Yoga.POSITION_TYPE_ABSOLUTE'},
YGPositionTypeRelative:{value:'Yoga.POSITION_TYPE_RELATIVE'},
YGAuto:{value:'Yoga.AUTO'},
YGWrapNoWrap:{value:'Yoga.WRAP_NO_WRAP'},
YGWrapWrap:{value:'Yoga.WRAP_WRAP'},
YGWrapWrapReverse:{value: 'Yoga.WRAP_WRAP_REVERSE'},
YGPositionTypeAbsolute:{value: 'PositionType.Absolute'},
YGPositionTypeRelative:{value: 'PositionType.Relative'},
YGAuto:{value:'\'auto\''},
YGUndefined:{value:'undefined'},
YGDisplayFlex:{value:'Yoga.DISPLAY_FLEX'},
YGDisplayNone:{value:'Yoga.DISPLAY_NONE'},
YGWrapNoWrap:{value: 'Wrap.NoWrap'},
YGWrapWrap:{value: 'Wrap.Wrap'},
YGWrapWrapReverse:{value: 'Wrap.WrapReverse'},
YGDisplayFlex:{value: 'Display.Flex'},
YGDisplayNone:{value: 'Display.None'},
YGNodeCalculateLayout:{value:function(node, dir, experiments) {
this.push(node + '.calculateLayout(undefined, undefined, ' + dir + ');');

2
gentest/gentest.rb
View File

@@ -56,7 +56,7 @@ Dir['fixtures/*.html'].each do |file|
print logs[4]
f = File.open("../javascript/tests/generated/#{name}.test.js", 'w')
f = File.open("../javascript/tests/generated/#{name}.test.ts", 'w')
f.write eval(logs[3].message.sub(/^[^"]*/, '')).sub('YogaTest', name)
f.close
end

10
javascript/jest.config.ts
View File

@@ -12,6 +12,16 @@ import type {Config} from 'jest';
const config: Config = {
setupFiles: ['./jest.setup.ts'],
testRegex: '/tests/.*\\.test\\.[jt]s$',
moduleNameMapper: {
'yoga-layout':
process.env['SYNC'] === '1' && process.env['WASM'] === '1'
? 'yoga-layout/wasm-sync'
: process.env['SYNC'] === '1'
? 'yoga-layout/asmjs-sync'
: process.env['WASM'] === '1'
? 'yoga-layout/wasm-async'
: 'yoga-layout/asmjs-async',
},
};
export default config;

11
javascript/jest.setup.ts
View File

@@ -8,15 +8,8 @@
*/
module.exports = async () => {
if (process.env['SYNC'] === '1' && process.env['WASM'] === '1') {
globalThis.Yoga = require('yoga-layout/wasm-sync').default;
} else if (process.env['SYNC'] === '1') {
globalThis.Yoga = require('yoga-layout/asmjs-sync').default;
} else if (process.env['WASM'] === '1') {
globalThis.Yoga = await require('yoga-layout/wasm-async').loadYoga();
} else {
globalThis.Yoga = await require('yoga-layout/asmjs-async').loadYoga();
}
const {loadYoga, default: Yoga} = require('yoga-layout');
globalThis.Yoga = Yoga ?? (await loadYoga());
};
Object.defineProperty(globalThis, 'YGBENCHMARK', {

434
javascript/tests/generated/YGAbsolutePositionTest.test.js → javascript/tests/generated/YGAbsolutePositionTest.test.ts
View File

@@ -7,12 +7,30 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGAbsolutePositionTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('absolute_layout_width_height_start_top', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -20,13 +38,13 @@ test('absolute_layout_width_height_start_top', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_START, 10);
root_child0.setPosition(Yoga.EDGE_TOP, 10);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Start, 10);
root_child0.setPosition(Edge.Top, 10);
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -38,7 +56,7 @@ test('absolute_layout_width_height_start_top', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -61,8 +79,8 @@ test('absolute_layout_width_height_end_bottom', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -70,13 +88,13 @@ test('absolute_layout_width_height_end_bottom', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_END, 10);
root_child0.setPosition(Yoga.EDGE_BOTTOM, 10);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.End, 10);
root_child0.setPosition(Edge.Bottom, 10);
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -88,7 +106,7 @@ test('absolute_layout_width_height_end_bottom', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -111,8 +129,8 @@ test('absolute_layout_start_top_end_bottom', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -120,13 +138,13 @@ test('absolute_layout_start_top_end_bottom', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_START, 10);
root_child0.setPosition(Yoga.EDGE_TOP, 10);
root_child0.setPosition(Yoga.EDGE_END, 10);
root_child0.setPosition(Yoga.EDGE_BOTTOM, 10);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Start, 10);
root_child0.setPosition(Edge.Top, 10);
root_child0.setPosition(Edge.End, 10);
root_child0.setPosition(Edge.Bottom, 10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -138,7 +156,7 @@ test('absolute_layout_start_top_end_bottom', () => {
expect(root_child0.getComputedWidth()).toBe(80);
expect(root_child0.getComputedHeight()).toBe(80);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -161,8 +179,8 @@ test('absolute_layout_width_height_start_top_end_bottom', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -170,15 +188,15 @@ test('absolute_layout_width_height_start_top_end_bottom', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_START, 10);
root_child0.setPosition(Yoga.EDGE_TOP, 10);
root_child0.setPosition(Yoga.EDGE_END, 10);
root_child0.setPosition(Yoga.EDGE_BOTTOM, 10);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Start, 10);
root_child0.setPosition(Edge.Top, 10);
root_child0.setPosition(Edge.End, 10);
root_child0.setPosition(Edge.Bottom, 10);
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -190,7 +208,7 @@ test('absolute_layout_width_height_start_top_end_bottom', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -213,27 +231,27 @@ test('do_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hidden_pare
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setOverflow(Yoga.OVERFLOW_HIDDEN);
root.setFlexDirection(FlexDirection.Row);
root.setOverflow(Overflow.Hidden);
root.setWidth(50);
root.setHeight(50);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_START, 0);
root_child0.setPosition(Yoga.EDGE_TOP, 0);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Start, 0);
root_child0.setPosition(Edge.Top, 0);
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setWidth(100);
root_child0_child0.setHeight(100);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -250,7 +268,7 @@ test('do_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hidden_pare
expect(root_child0_child0.getComputedWidth()).toBe(100);
expect(root_child0_child0.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -278,66 +296,66 @@ test('absolute_layout_within_border', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setMargin(Yoga.EDGE_LEFT, 10);
root.setMargin(Yoga.EDGE_TOP, 10);
root.setMargin(Yoga.EDGE_RIGHT, 10);
root.setMargin(Yoga.EDGE_BOTTOM, 10);
root.setPadding(Yoga.EDGE_LEFT, 10);
root.setPadding(Yoga.EDGE_TOP, 10);
root.setPadding(Yoga.EDGE_RIGHT, 10);
root.setPadding(Yoga.EDGE_BOTTOM, 10);
root.setBorder(Yoga.EDGE_LEFT, 10);
root.setBorder(Yoga.EDGE_TOP, 10);
root.setBorder(Yoga.EDGE_RIGHT, 10);
root.setBorder(Yoga.EDGE_BOTTOM, 10);
root.setMargin(Edge.Left, 10);
root.setMargin(Edge.Top, 10);
root.setMargin(Edge.Right, 10);
root.setMargin(Edge.Bottom, 10);
root.setPadding(Edge.Left, 10);
root.setPadding(Edge.Top, 10);
root.setPadding(Edge.Right, 10);
root.setPadding(Edge.Bottom, 10);
root.setBorder(Edge.Left, 10);
root.setBorder(Edge.Top, 10);
root.setBorder(Edge.Right, 10);
root.setBorder(Edge.Bottom, 10);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_LEFT, 0);
root_child0.setPosition(Yoga.EDGE_TOP, 0);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Left, 0);
root_child0.setPosition(Edge.Top, 0);
root_child0.setWidth(50);
root_child0.setHeight(50);
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child1.setPosition(Yoga.EDGE_RIGHT, 0);
root_child1.setPosition(Yoga.EDGE_BOTTOM, 0);
root_child1.setPositionType(PositionType.Absolute);
root_child1.setPosition(Edge.Right, 0);
root_child1.setPosition(Edge.Bottom, 0);
root_child1.setWidth(50);
root_child1.setHeight(50);
root.insertChild(root_child1, 1);
const root_child2 = Yoga.Node.create(config);
root_child2.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child2.setPosition(Yoga.EDGE_LEFT, 0);
root_child2.setPosition(Yoga.EDGE_TOP, 0);
root_child2.setMargin(Yoga.EDGE_LEFT, 10);
root_child2.setMargin(Yoga.EDGE_TOP, 10);
root_child2.setMargin(Yoga.EDGE_RIGHT, 10);
root_child2.setMargin(Yoga.EDGE_BOTTOM, 10);
root_child2.setPositionType(PositionType.Absolute);
root_child2.setPosition(Edge.Left, 0);
root_child2.setPosition(Edge.Top, 0);
root_child2.setMargin(Edge.Left, 10);
root_child2.setMargin(Edge.Top, 10);
root_child2.setMargin(Edge.Right, 10);
root_child2.setMargin(Edge.Bottom, 10);
root_child2.setWidth(50);
root_child2.setHeight(50);
root.insertChild(root_child2, 2);
const root_child3 = Yoga.Node.create(config);
root_child3.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child3.setPosition(Yoga.EDGE_RIGHT, 0);
root_child3.setPosition(Yoga.EDGE_BOTTOM, 0);
root_child3.setMargin(Yoga.EDGE_LEFT, 10);
root_child3.setMargin(Yoga.EDGE_TOP, 10);
root_child3.setMargin(Yoga.EDGE_RIGHT, 10);
root_child3.setMargin(Yoga.EDGE_BOTTOM, 10);
root_child3.setPositionType(PositionType.Absolute);
root_child3.setPosition(Edge.Right, 0);
root_child3.setPosition(Edge.Bottom, 0);
root_child3.setMargin(Edge.Left, 10);
root_child3.setMargin(Edge.Top, 10);
root_child3.setMargin(Edge.Right, 10);
root_child3.setMargin(Edge.Bottom, 10);
root_child3.setWidth(50);
root_child3.setHeight(50);
root.insertChild(root_child3, 3);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(10);
expect(root.getComputedTop()).toBe(10);
@@ -364,7 +382,7 @@ test('absolute_layout_within_border', () => {
expect(root_child3.getComputedWidth()).toBe(50);
expect(root_child3.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(10);
expect(root.getComputedTop()).toBe(10);
@@ -402,23 +420,23 @@ test('absolute_layout_align_items_and_justify_content_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setJustifyContent(Justify.Center);
root.setAlignItems(Align.Center);
root.setFlexGrow(1);
root.setWidth(110);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(60);
root_child0.setHeight(40);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -430,7 +448,7 @@ test('absolute_layout_align_items_and_justify_content_center', () => {
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -453,23 +471,23 @@ test('absolute_layout_align_items_and_justify_content_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_FLEX_END);
root.setAlignItems(Yoga.ALIGN_FLEX_END);
root.setJustifyContent(Justify.FlexEnd);
root.setAlignItems(Align.FlexEnd);
root.setFlexGrow(1);
root.setWidth(110);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(60);
root_child0.setHeight(40);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -481,7 +499,7 @@ test('absolute_layout_align_items_and_justify_content_flex_end', () => {
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -504,22 +522,22 @@ test('absolute_layout_justify_content_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setJustifyContent(Justify.Center);
root.setFlexGrow(1);
root.setWidth(110);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(60);
root_child0.setHeight(40);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -531,7 +549,7 @@ test('absolute_layout_justify_content_center', () => {
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -554,22 +572,22 @@ test('absolute_layout_align_items_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setAlignItems(Align.Center);
root.setFlexGrow(1);
root.setWidth(110);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(60);
root_child0.setHeight(40);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -581,7 +599,7 @@ test('absolute_layout_align_items_center', () => {
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -604,8 +622,8 @@ test('absolute_layout_align_items_center_on_child_only', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -614,12 +632,12 @@ test('absolute_layout_align_items_center_on_child_only', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setAlignSelf(Yoga.ALIGN_CENTER);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setAlignSelf(Align.Center);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(60);
root_child0.setHeight(40);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -631,7 +649,7 @@ test('absolute_layout_align_items_center_on_child_only', () => {
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -654,24 +672,24 @@ test('absolute_layout_align_items_and_justify_content_center_and_top_position',
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setJustifyContent(Justify.Center);
root.setAlignItems(Align.Center);
root.setFlexGrow(1);
root.setWidth(110);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_TOP, 10);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Top, 10);
root_child0.setWidth(60);
root_child0.setHeight(40);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -683,7 +701,7 @@ test('absolute_layout_align_items_and_justify_content_center_and_top_position',
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -706,24 +724,24 @@ test('absolute_layout_align_items_and_justify_content_center_and_bottom_position
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setJustifyContent(Justify.Center);
root.setAlignItems(Align.Center);
root.setFlexGrow(1);
root.setWidth(110);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_BOTTOM, 10);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Bottom, 10);
root_child0.setWidth(60);
root_child0.setHeight(40);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -735,7 +753,7 @@ test('absolute_layout_align_items_and_justify_content_center_and_bottom_position
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -758,24 +776,24 @@ test('absolute_layout_align_items_and_justify_content_center_and_left_position',
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setJustifyContent(Justify.Center);
root.setAlignItems(Align.Center);
root.setFlexGrow(1);
root.setWidth(110);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_LEFT, 5);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Left, 5);
root_child0.setWidth(60);
root_child0.setHeight(40);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -787,7 +805,7 @@ test('absolute_layout_align_items_and_justify_content_center_and_left_position',
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -810,24 +828,24 @@ test('absolute_layout_align_items_and_justify_content_center_and_right_position'
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setJustifyContent(Justify.Center);
root.setAlignItems(Align.Center);
root.setFlexGrow(1);
root.setWidth(110);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_RIGHT, 5);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Right, 5);
root_child0.setWidth(60);
root_child0.setHeight(40);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -839,7 +857,7 @@ test('absolute_layout_align_items_and_justify_content_center_and_right_position'
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -862,22 +880,22 @@ test('position_root_with_rtl_should_position_withoutdirection', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setPosition(Yoga.EDGE_LEFT, 72);
root.setPosition(Edge.Left, 72);
root.setWidth(52);
root.setHeight(52);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(72);
expect(root.getComputedTop()).toBe(0);
expect(root.getComputedWidth()).toBe(52);
expect(root.getComputedHeight()).toBe(52);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(72);
expect(root.getComputedTop()).toBe(0);
@@ -895,8 +913,8 @@ test('absolute_layout_percentage_bottom_based_on_parent_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -904,26 +922,26 @@ test('absolute_layout_percentage_bottom_based_on_parent_height', () => {
root.setHeight(200);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_TOP, "50%");
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Top, "50%");
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child1.setPosition(Yoga.EDGE_BOTTOM, "50%");
root_child1.setPositionType(PositionType.Absolute);
root_child1.setPosition(Edge.Bottom, "50%");
root_child1.setWidth(10);
root_child1.setHeight(10);
root.insertChild(root_child1, 1);
const root_child2 = Yoga.Node.create(config);
root_child2.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child2.setPosition(Yoga.EDGE_TOP, "10%");
root_child2.setPosition(Yoga.EDGE_BOTTOM, "10%");
root_child2.setPositionType(PositionType.Absolute);
root_child2.setPosition(Edge.Top, "10%");
root_child2.setPosition(Edge.Bottom, "10%");
root_child2.setWidth(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -945,7 +963,7 @@ test('absolute_layout_percentage_bottom_based_on_parent_height', () => {
expect(root_child2.getComputedWidth()).toBe(10);
expect(root_child2.getComputedHeight()).toBe(160);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -978,21 +996,21 @@ test('absolute_layout_in_wrap_reverse_column_container', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
root.setFlexWrap(Wrap.WrapReverse);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(20);
root_child0.setHeight(20);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1004,7 +1022,7 @@ test('absolute_layout_in_wrap_reverse_column_container', () => {
expect(root_child0.getComputedWidth()).toBe(20);
expect(root_child0.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1027,22 +1045,22 @@ test('absolute_layout_in_wrap_reverse_row_container', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.WrapReverse);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(20);
root_child0.setHeight(20);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1054,7 +1072,7 @@ test('absolute_layout_in_wrap_reverse_row_container', () => {
expect(root_child0.getComputedWidth()).toBe(20);
expect(root_child0.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1077,22 +1095,22 @@ test('absolute_layout_in_wrap_reverse_column_container_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
root.setFlexWrap(Wrap.WrapReverse);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setAlignSelf(Yoga.ALIGN_FLEX_END);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setAlignSelf(Align.FlexEnd);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(20);
root_child0.setHeight(20);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1104,7 +1122,7 @@ test('absolute_layout_in_wrap_reverse_column_container_flex_end', () => {
expect(root_child0.getComputedWidth()).toBe(20);
expect(root_child0.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1127,23 +1145,23 @@ test('absolute_layout_in_wrap_reverse_row_container_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.WrapReverse);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setAlignSelf(Yoga.ALIGN_FLEX_END);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setAlignSelf(Align.FlexEnd);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(20);
root_child0.setHeight(20);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1155,7 +1173,7 @@ test('absolute_layout_in_wrap_reverse_row_container_flex_end', () => {
expect(root_child0.getComputedWidth()).toBe(20);
expect(root_child0.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1178,8 +1196,8 @@ test('percent_absolute_position_infinite_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -1190,13 +1208,13 @@ test('percent_absolute_position_infinite_height', () => {
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child1.setPosition(Yoga.EDGE_LEFT, "20%");
root_child1.setPosition(Yoga.EDGE_TOP, "20%");
root_child1.setPositionType(PositionType.Absolute);
root_child1.setPosition(Edge.Left, "20%");
root_child1.setPosition(Edge.Top, "20%");
root_child1.setWidth("20%");
root_child1.setHeight("20%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1213,7 +1231,7 @@ test('percent_absolute_position_infinite_height', () => {
expect(root_child1.getComputedWidth()).toBe(60);
expect(root_child1.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1241,22 +1259,22 @@ test('absolute_layout_percentage_height_based_on_padded_parent', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setPadding(Yoga.EDGE_TOP, 10);
root.setBorder(Yoga.EDGE_TOP, 10);
root.setPadding(Edge.Top, 10);
root.setBorder(Edge.Top, 10);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(100);
root_child0.setHeight("50%");
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1268,7 +1286,7 @@ test('absolute_layout_percentage_height_based_on_padded_parent', () => {
expect(root_child0.getComputedWidth()).toBe(100);
expect(root_child0.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1291,24 +1309,24 @@ test('absolute_layout_percentage_height_based_on_padded_parent_and_align_items_c
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setPadding(Yoga.EDGE_TOP, 20);
root.setPadding(Yoga.EDGE_BOTTOM, 20);
root.setJustifyContent(Justify.Center);
root.setAlignItems(Align.Center);
root.setPadding(Edge.Top, 20);
root.setPadding(Edge.Bottom, 20);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(100);
root_child0.setHeight("50%");
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1320,7 +1338,7 @@ test('absolute_layout_percentage_height_based_on_padded_parent_and_align_items_c
expect(root_child0.getComputedWidth()).toBe(100);
expect(root_child0.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

304
javascript/tests/generated/YGAlignContentTest.test.js → javascript/tests/generated/YGAlignContentTest.test.ts
View File

@@ -7,17 +7,35 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGAlignContentTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('align_content_flex_start', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(130);
root.setHeight(100);
@@ -45,7 +63,7 @@ test('align_content_flex_start', () => {
root_child4.setWidth(50);
root_child4.setHeight(10);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -77,7 +95,7 @@ test('align_content_flex_start', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -120,12 +138,12 @@ test('align_content_flex_start_without_height_on_children', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(100);
@@ -150,7 +168,7 @@ test('align_content_flex_start_without_height_on_children', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -182,7 +200,7 @@ test('align_content_flex_start_without_height_on_children', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -225,12 +243,12 @@ test('align_content_flex_start_with_flex', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(120);
@@ -261,7 +279,7 @@ test('align_content_flex_start_with_flex', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -293,7 +311,7 @@ test('align_content_flex_start_with_flex', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -336,13 +354,13 @@ test('align_content_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignContent(Yoga.ALIGN_FLEX_END);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setAlignContent(Align.FlexEnd);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(100);
@@ -370,7 +388,7 @@ test('align_content_flex_end', () => {
root_child4.setWidth(50);
root_child4.setHeight(10);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -402,7 +420,7 @@ test('align_content_flex_end', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -445,13 +463,13 @@ test('align_content_stretch', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -474,7 +492,7 @@ test('align_content_stretch', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -506,7 +524,7 @@ test('align_content_stretch', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -549,14 +567,14 @@ test('align_content_spacebetween', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_SPACE_BETWEEN);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.SpaceBetween);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(130);
root.setHeight(100);
@@ -584,7 +602,7 @@ test('align_content_spacebetween', () => {
root_child4.setWidth(50);
root_child4.setHeight(10);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -616,7 +634,7 @@ test('align_content_spacebetween', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -659,14 +677,14 @@ test('align_content_spacearound', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_SPACE_AROUND);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.SpaceAround);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(140);
root.setHeight(120);
@@ -694,7 +712,7 @@ test('align_content_spacearound', () => {
root_child4.setWidth(50);
root_child4.setHeight(10);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -726,7 +744,7 @@ test('align_content_spacearound', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -769,14 +787,14 @@ test('align_content_stretch_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -799,7 +817,7 @@ test('align_content_stretch_row', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -831,7 +849,7 @@ test('align_content_stretch_row', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -874,14 +892,14 @@ test('align_content_stretch_row_with_children', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -910,7 +928,7 @@ test('align_content_stretch_row_with_children', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -947,7 +965,7 @@ test('align_content_stretch_row_with_children', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -995,14 +1013,14 @@ test('align_content_stretch_row_with_flex', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -1031,7 +1049,7 @@ test('align_content_stretch_row_with_flex', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1063,7 +1081,7 @@ test('align_content_stretch_row_with_flex', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1106,14 +1124,14 @@ test('align_content_stretch_row_with_flex_no_shrink', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -1141,7 +1159,7 @@ test('align_content_stretch_row_with_flex_no_shrink', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1173,7 +1191,7 @@ test('align_content_stretch_row_with_flex_no_shrink', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1216,14 +1234,14 @@ test('align_content_stretch_row_with_margin', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -1232,10 +1250,10 @@ test('align_content_stretch_row_with_margin', () => {
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setMargin(Yoga.EDGE_LEFT, 10);
root_child1.setMargin(Yoga.EDGE_TOP, 10);
root_child1.setMargin(Yoga.EDGE_RIGHT, 10);
root_child1.setMargin(Yoga.EDGE_BOTTOM, 10);
root_child1.setMargin(Edge.Left, 10);
root_child1.setMargin(Edge.Top, 10);
root_child1.setMargin(Edge.Right, 10);
root_child1.setMargin(Edge.Bottom, 10);
root_child1.setWidth(50);
root.insertChild(root_child1, 1);
@@ -1244,17 +1262,17 @@ test('align_content_stretch_row_with_margin', () => {
root.insertChild(root_child2, 2);
const root_child3 = Yoga.Node.create(config);
root_child3.setMargin(Yoga.EDGE_LEFT, 10);
root_child3.setMargin(Yoga.EDGE_TOP, 10);
root_child3.setMargin(Yoga.EDGE_RIGHT, 10);
root_child3.setMargin(Yoga.EDGE_BOTTOM, 10);
root_child3.setMargin(Edge.Left, 10);
root_child3.setMargin(Edge.Top, 10);
root_child3.setMargin(Edge.Right, 10);
root_child3.setMargin(Edge.Bottom, 10);
root_child3.setWidth(50);
root.insertChild(root_child3, 3);
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1286,7 +1304,7 @@ test('align_content_stretch_row_with_margin', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1329,14 +1347,14 @@ test('align_content_stretch_row_with_padding', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -1345,10 +1363,10 @@ test('align_content_stretch_row_with_padding', () => {
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setPadding(Yoga.EDGE_LEFT, 10);
root_child1.setPadding(Yoga.EDGE_TOP, 10);
root_child1.setPadding(Yoga.EDGE_RIGHT, 10);
root_child1.setPadding(Yoga.EDGE_BOTTOM, 10);
root_child1.setPadding(Edge.Left, 10);
root_child1.setPadding(Edge.Top, 10);
root_child1.setPadding(Edge.Right, 10);
root_child1.setPadding(Edge.Bottom, 10);
root_child1.setWidth(50);
root.insertChild(root_child1, 1);
@@ -1357,17 +1375,17 @@ test('align_content_stretch_row_with_padding', () => {
root.insertChild(root_child2, 2);
const root_child3 = Yoga.Node.create(config);
root_child3.setPadding(Yoga.EDGE_LEFT, 10);
root_child3.setPadding(Yoga.EDGE_TOP, 10);
root_child3.setPadding(Yoga.EDGE_RIGHT, 10);
root_child3.setPadding(Yoga.EDGE_BOTTOM, 10);
root_child3.setPadding(Edge.Left, 10);
root_child3.setPadding(Edge.Top, 10);
root_child3.setPadding(Edge.Right, 10);
root_child3.setPadding(Edge.Bottom, 10);
root_child3.setWidth(50);
root.insertChild(root_child3, 3);
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1399,7 +1417,7 @@ test('align_content_stretch_row_with_padding', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1442,14 +1460,14 @@ test('align_content_stretch_row_with_single_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -1460,7 +1478,7 @@ test('align_content_stretch_row_with_single_row', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setWidth(50);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1477,7 +1495,7 @@ test('align_content_stretch_row_with_single_row', () => {
expect(root_child1.getComputedWidth()).toBe(50);
expect(root_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1505,14 +1523,14 @@ test('align_content_stretch_row_with_fixed_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -1536,7 +1554,7 @@ test('align_content_stretch_row_with_fixed_height', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1568,7 +1586,7 @@ test('align_content_stretch_row_with_fixed_height', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1611,14 +1629,14 @@ test('align_content_stretch_row_with_max_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -1642,7 +1660,7 @@ test('align_content_stretch_row_with_max_height', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1674,7 +1692,7 @@ test('align_content_stretch_row_with_max_height', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1717,14 +1735,14 @@ test('align_content_stretch_row_with_min_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -1748,7 +1766,7 @@ test('align_content_stretch_row_with_min_height', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setWidth(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1780,7 +1798,7 @@ test('align_content_stretch_row_with_min_height', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1823,13 +1841,13 @@ test('align_content_stretch_column', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(150);
@@ -1861,7 +1879,7 @@ test('align_content_stretch_column', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setHeight(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1898,7 +1916,7 @@ test('align_content_stretch_column', () => {
expect(root_child4.getComputedWidth()).toBe(50);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1946,27 +1964,27 @@ test('align_content_stretch_is_not_overriding_align_items', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setAlignContent(Align.Stretch);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0.setAlignItems(Yoga.ALIGN_CENTER);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setAlignContent(Align.Stretch);
root_child0.setAlignItems(Align.Center);
root_child0.setWidth(100);
root_child0.setHeight(100);
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0.setWidth(10);
root_child0_child0.setHeight(10);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1983,7 +2001,7 @@ test('align_content_stretch_is_not_overriding_align_items', () => {
expect(root_child0_child0.getComputedWidth()).toBe(10);
expect(root_child0_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

410
javascript/tests/generated/YGAlignItemsTest.test.js → javascript/tests/generated/YGAlignItemsTest.test.ts
View File

File diff suppressed because it is too large Load Diff

74
javascript/tests/generated/YGAlignSelfTest.test.js → javascript/tests/generated/YGAlignSelfTest.test.ts
View File

@@ -7,12 +7,30 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGAlignSelfTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('align_self_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -20,11 +38,11 @@ test('align_self_center', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setAlignSelf(Yoga.ALIGN_CENTER);
root_child0.setAlignSelf(Align.Center);
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -36,7 +54,7 @@ test('align_self_center', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -59,8 +77,8 @@ test('align_self_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -68,11 +86,11 @@ test('align_self_flex_end', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setAlignSelf(Yoga.ALIGN_FLEX_END);
root_child0.setAlignSelf(Align.FlexEnd);
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -84,7 +102,7 @@ test('align_self_flex_end', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -107,8 +125,8 @@ test('align_self_flex_start', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -116,11 +134,11 @@ test('align_self_flex_start', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setAlignSelf(Yoga.ALIGN_FLEX_START);
root_child0.setAlignSelf(Align.FlexStart);
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -132,7 +150,7 @@ test('align_self_flex_start', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -155,21 +173,21 @@ test('align_self_flex_end_override_flex_start', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignItems(Yoga.ALIGN_FLEX_START);
root.setAlignItems(Align.FlexStart);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setAlignSelf(Yoga.ALIGN_FLEX_END);
root_child0.setAlignSelf(Align.FlexEnd);
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -181,7 +199,7 @@ test('align_self_flex_end_override_flex_start', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -204,23 +222,23 @@ test('align_self_baseline', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setAlignSelf(Yoga.ALIGN_BASELINE);
root_child0.setAlignSelf(Align.Baseline);
root_child0.setWidth(50);
root_child0.setHeight(50);
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setAlignSelf(Yoga.ALIGN_BASELINE);
root_child1.setAlignSelf(Align.Baseline);
root_child1.setWidth(50);
root_child1.setHeight(20);
root.insertChild(root_child1, 1);
@@ -229,7 +247,7 @@ test('align_self_baseline', () => {
root_child1_child0.setWidth(50);
root_child1_child0.setHeight(10);
root_child1.insertChild(root_child1_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -251,7 +269,7 @@ test('align_self_baseline', () => {
expect(root_child1_child0.getComputedWidth()).toBe(50);
expect(root_child1_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

102
javascript/tests/generated/YGAndroidNewsFeed.test.js → javascript/tests/generated/YGAndroidNewsFeed.test.ts
View File

@@ -7,113 +7,131 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGAndroidNewsFeed.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('android_news_feed', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setAlignContent(Align.Stretch);
root.setWidth(1080);
const root_child0 = Yoga.Node.create(config);
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0.setAlignContent(Align.Stretch);
root_child0.insertChild(root_child0_child0, 0);
const root_child0_child0_child0 = Yoga.Node.create(config);
root_child0_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0.insertChild(root_child0_child0_child0, 0);
const root_child0_child0_child0_child0 = Yoga.Node.create(config);
root_child0_child0_child0_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child0_child0.setAlignItems(Yoga.ALIGN_FLEX_START);
root_child0_child0_child0_child0.setMargin(Yoga.EDGE_START, 36);
root_child0_child0_child0_child0.setMargin(Yoga.EDGE_TOP, 24);
root_child0_child0_child0_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0_child0_child0.setAlignItems(Align.FlexStart);
root_child0_child0_child0_child0.setMargin(Edge.Start, 36);
root_child0_child0_child0_child0.setMargin(Edge.Top, 24);
root_child0_child0_child0.insertChild(root_child0_child0_child0_child0, 0);
const root_child0_child0_child0_child0_child0 = Yoga.Node.create(config);
root_child0_child0_child0_child0_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0_child0_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child0_child0_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0_child0_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0_child0_child0.insertChild(root_child0_child0_child0_child0_child0, 0);
const root_child0_child0_child0_child0_child0_child0 = Yoga.Node.create(config);
root_child0_child0_child0_child0_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child0_child0_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0_child0_child0_child0_child0.setWidth(120);
root_child0_child0_child0_child0_child0_child0.setHeight(120);
root_child0_child0_child0_child0_child0.insertChild(root_child0_child0_child0_child0_child0_child0, 0);
const root_child0_child0_child0_child0_child1 = Yoga.Node.create(config);
root_child0_child0_child0_child0_child1.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child0_child0_child1.setAlignContent(Align.Stretch);
root_child0_child0_child0_child0_child1.setFlexShrink(1);
root_child0_child0_child0_child0_child1.setMargin(Yoga.EDGE_RIGHT, 36);
root_child0_child0_child0_child0_child1.setPadding(Yoga.EDGE_LEFT, 36);
root_child0_child0_child0_child0_child1.setPadding(Yoga.EDGE_TOP, 21);
root_child0_child0_child0_child0_child1.setPadding(Yoga.EDGE_RIGHT, 36);
root_child0_child0_child0_child0_child1.setPadding(Yoga.EDGE_BOTTOM, 18);
root_child0_child0_child0_child0_child1.setMargin(Edge.Right, 36);
root_child0_child0_child0_child0_child1.setPadding(Edge.Left, 36);
root_child0_child0_child0_child0_child1.setPadding(Edge.Top, 21);
root_child0_child0_child0_child0_child1.setPadding(Edge.Right, 36);
root_child0_child0_child0_child0_child1.setPadding(Edge.Bottom, 18);
root_child0_child0_child0_child0.insertChild(root_child0_child0_child0_child0_child1, 1);
const root_child0_child0_child0_child0_child1_child0 = Yoga.Node.create(config);
root_child0_child0_child0_child0_child1_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0_child0_child0_child1_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child0_child0_child1_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0_child0_child0_child1_child0.setAlignContent(Align.Stretch);
root_child0_child0_child0_child0_child1_child0.setFlexShrink(1);
root_child0_child0_child0_child0_child1.insertChild(root_child0_child0_child0_child0_child1_child0, 0);
const root_child0_child0_child0_child0_child1_child1 = Yoga.Node.create(config);
root_child0_child0_child0_child0_child1_child1.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child0_child0_child1_child1.setAlignContent(Align.Stretch);
root_child0_child0_child0_child0_child1_child1.setFlexShrink(1);
root_child0_child0_child0_child0_child1.insertChild(root_child0_child0_child0_child0_child1_child1, 1);
const root_child0_child0_child1 = Yoga.Node.create(config);
root_child0_child0_child1.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child1.setAlignContent(Align.Stretch);
root_child0_child0.insertChild(root_child0_child0_child1, 1);
const root_child0_child0_child1_child0 = Yoga.Node.create(config);
root_child0_child0_child1_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0_child1_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child1_child0.setAlignItems(Yoga.ALIGN_FLEX_START);
root_child0_child0_child1_child0.setMargin(Yoga.EDGE_START, 174);
root_child0_child0_child1_child0.setMargin(Yoga.EDGE_TOP, 24);
root_child0_child0_child1_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0_child1_child0.setAlignContent(Align.Stretch);
root_child0_child0_child1_child0.setAlignItems(Align.FlexStart);
root_child0_child0_child1_child0.setMargin(Edge.Start, 174);
root_child0_child0_child1_child0.setMargin(Edge.Top, 24);
root_child0_child0_child1.insertChild(root_child0_child0_child1_child0, 0);
const root_child0_child0_child1_child0_child0 = Yoga.Node.create(config);
root_child0_child0_child1_child0_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0_child1_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child1_child0_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0_child1_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0_child1_child0.insertChild(root_child0_child0_child1_child0_child0, 0);
const root_child0_child0_child1_child0_child0_child0 = Yoga.Node.create(config);
root_child0_child0_child1_child0_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child1_child0_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0_child1_child0_child0_child0.setWidth(72);
root_child0_child0_child1_child0_child0_child0.setHeight(72);
root_child0_child0_child1_child0_child0.insertChild(root_child0_child0_child1_child0_child0_child0, 0);
const root_child0_child0_child1_child0_child1 = Yoga.Node.create(config);
root_child0_child0_child1_child0_child1.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child1_child0_child1.setAlignContent(Align.Stretch);
root_child0_child0_child1_child0_child1.setFlexShrink(1);
root_child0_child0_child1_child0_child1.setMargin(Yoga.EDGE_RIGHT, 36);
root_child0_child0_child1_child0_child1.setPadding(Yoga.EDGE_LEFT, 36);
root_child0_child0_child1_child0_child1.setPadding(Yoga.EDGE_TOP, 21);
root_child0_child0_child1_child0_child1.setPadding(Yoga.EDGE_RIGHT, 36);
root_child0_child0_child1_child0_child1.setPadding(Yoga.EDGE_BOTTOM, 18);
root_child0_child0_child1_child0_child1.setMargin(Edge.Right, 36);
root_child0_child0_child1_child0_child1.setPadding(Edge.Left, 36);
root_child0_child0_child1_child0_child1.setPadding(Edge.Top, 21);
root_child0_child0_child1_child0_child1.setPadding(Edge.Right, 36);
root_child0_child0_child1_child0_child1.setPadding(Edge.Bottom, 18);
root_child0_child0_child1_child0.insertChild(root_child0_child0_child1_child0_child1, 1);
const root_child0_child0_child1_child0_child1_child0 = Yoga.Node.create(config);
root_child0_child0_child1_child0_child1_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0_child1_child0_child1_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child1_child0_child1_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0_child1_child0_child1_child0.setAlignContent(Align.Stretch);
root_child0_child0_child1_child0_child1_child0.setFlexShrink(1);
root_child0_child0_child1_child0_child1.insertChild(root_child0_child0_child1_child0_child1_child0, 0);
const root_child0_child0_child1_child0_child1_child1 = Yoga.Node.create(config);
root_child0_child0_child1_child0_child1_child1.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child1_child0_child1_child1.setAlignContent(Align.Stretch);
root_child0_child0_child1_child0_child1_child1.setFlexShrink(1);
root_child0_child0_child1_child0_child1.insertChild(root_child0_child0_child1_child0_child1_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -200,7 +218,7 @@ test('android_news_feed', () => {
expect(root_child0_child0_child1_child0_child1_child1.getComputedWidth()).toBe(0);
expect(root_child0_child0_child1_child0_child1_child1.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

100
javascript/tests/generated/YGBorderTest.test.js → javascript/tests/generated/YGBorderTest.test.ts
View File

@@ -7,27 +7,45 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGBorderTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('border_no_size', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setBorder(Yoga.EDGE_LEFT, 10);
root.setBorder(Yoga.EDGE_TOP, 10);
root.setBorder(Yoga.EDGE_RIGHT, 10);
root.setBorder(Yoga.EDGE_BOTTOM, 10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.setBorder(Edge.Left, 10);
root.setBorder(Edge.Top, 10);
root.setBorder(Edge.Right, 10);
root.setBorder(Edge.Bottom, 10);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
expect(root.getComputedWidth()).toBe(20);
expect(root.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -45,21 +63,21 @@ test('border_container_match_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setBorder(Yoga.EDGE_LEFT, 10);
root.setBorder(Yoga.EDGE_TOP, 10);
root.setBorder(Yoga.EDGE_RIGHT, 10);
root.setBorder(Yoga.EDGE_BOTTOM, 10);
root.setBorder(Edge.Left, 10);
root.setBorder(Edge.Top, 10);
root.setBorder(Edge.Right, 10);
root.setBorder(Edge.Bottom, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -71,7 +89,7 @@ test('border_container_match_child', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -94,15 +112,15 @@ test('border_flex_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setBorder(Yoga.EDGE_LEFT, 10);
root.setBorder(Yoga.EDGE_TOP, 10);
root.setBorder(Yoga.EDGE_RIGHT, 10);
root.setBorder(Yoga.EDGE_BOTTOM, 10);
root.setBorder(Edge.Left, 10);
root.setBorder(Edge.Top, 10);
root.setBorder(Edge.Right, 10);
root.setBorder(Edge.Bottom, 10);
root.setWidth(100);
root.setHeight(100);
@@ -110,7 +128,7 @@ test('border_flex_child', () => {
root_child0.setFlexGrow(1);
root_child0.setWidth(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -122,7 +140,7 @@ test('border_flex_child', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(80);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -145,22 +163,22 @@ test('border_stretch_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setBorder(Yoga.EDGE_LEFT, 10);
root.setBorder(Yoga.EDGE_TOP, 10);
root.setBorder(Yoga.EDGE_RIGHT, 10);
root.setBorder(Yoga.EDGE_BOTTOM, 10);
root.setBorder(Edge.Left, 10);
root.setBorder(Edge.Top, 10);
root.setBorder(Edge.Right, 10);
root.setBorder(Edge.Bottom, 10);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -172,7 +190,7 @@ test('border_stretch_child', () => {
expect(root_child0.getComputedWidth()).toBe(80);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -195,16 +213,16 @@ test('border_center_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setBorder(Yoga.EDGE_START, 10);
root.setBorder(Yoga.EDGE_END, 20);
root.setBorder(Yoga.EDGE_BOTTOM, 20);
root.setJustifyContent(Justify.Center);
root.setAlignItems(Align.Center);
root.setBorder(Edge.Start, 10);
root.setBorder(Edge.End, 20);
root.setBorder(Edge.Bottom, 20);
root.setWidth(100);
root.setHeight(100);
@@ -212,7 +230,7 @@ test('border_center_child', () => {
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -224,7 +242,7 @@ test('border_center_child', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

34
javascript/tests/generated/YGDimensionTest.test.js → javascript/tests/generated/YGDimensionTest.test.ts
View File

@@ -7,12 +7,30 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGDimensionTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('wrap_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -21,7 +39,7 @@ test('wrap_child', () => {
root_child0.setWidth(100);
root_child0.setHeight(100);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -33,7 +51,7 @@ test('wrap_child', () => {
expect(root_child0.getComputedWidth()).toBe(100);
expect(root_child0.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -56,8 +74,8 @@ test('wrap_grandchild', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -69,7 +87,7 @@ test('wrap_grandchild', () => {
root_child0_child0.setWidth(100);
root_child0_child0.setHeight(100);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -86,7 +104,7 @@ test('wrap_grandchild', () => {
expect(root_child0_child0.getComputedWidth()).toBe(100);
expect(root_child0_child0.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

100
javascript/tests/generated/YGDisplayTest.test.js → javascript/tests/generated/YGDisplayTest.test.ts
View File

@@ -7,16 +7,34 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGDisplayTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('display_none', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
@@ -26,9 +44,9 @@ test('display_none', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexGrow(1);
root_child1.setDisplay(Yoga.DISPLAY_NONE);
root_child1.setDisplay(Display.None);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -45,7 +63,7 @@ test('display_none', () => {
expect(root_child1.getComputedWidth()).toBe(0);
expect(root_child1.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -73,12 +91,12 @@ test('display_none_fixed_size', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
@@ -89,9 +107,9 @@ test('display_none_fixed_size', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setWidth(20);
root_child1.setHeight(20);
root_child1.setDisplay(Yoga.DISPLAY_NONE);
root_child1.setDisplay(Display.None);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -108,7 +126,7 @@ test('display_none_fixed_size', () => {
expect(root_child1.getComputedWidth()).toBe(0);
expect(root_child1.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -136,29 +154,29 @@ test('display_none_with_margin', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setMargin(Yoga.EDGE_LEFT, 10);
root_child0.setMargin(Yoga.EDGE_TOP, 10);
root_child0.setMargin(Yoga.EDGE_RIGHT, 10);
root_child0.setMargin(Yoga.EDGE_BOTTOM, 10);
root_child0.setMargin(Edge.Left, 10);
root_child0.setMargin(Edge.Top, 10);
root_child0.setMargin(Edge.Right, 10);
root_child0.setMargin(Edge.Bottom, 10);
root_child0.setWidth(20);
root_child0.setHeight(20);
root_child0.setDisplay(Yoga.DISPLAY_NONE);
root_child0.setDisplay(Display.None);
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexGrow(1);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -175,7 +193,7 @@ test('display_none_with_margin', () => {
expect(root_child1.getComputedWidth()).toBe(100);
expect(root_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -203,12 +221,12 @@ test('display_none_with_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
@@ -222,7 +240,7 @@ test('display_none_with_child', () => {
root_child1.setFlexGrow(1);
root_child1.setFlexShrink(1);
root_child1.setFlexBasis("0%");
root_child1.setDisplay(Yoga.DISPLAY_NONE);
root_child1.setDisplay(Display.None);
root.insertChild(root_child1, 1);
const root_child1_child0 = Yoga.Node.create(config);
@@ -237,7 +255,7 @@ test('display_none_with_child', () => {
root_child2.setFlexShrink(1);
root_child2.setFlexBasis("0%");
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -264,7 +282,7 @@ test('display_none_with_child', () => {
expect(root_child2.getComputedWidth()).toBe(50);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -302,12 +320,12 @@ test('display_none_with_position', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
@@ -317,10 +335,10 @@ test('display_none_with_position', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexGrow(1);
root_child1.setPosition(Yoga.EDGE_TOP, 10);
root_child1.setDisplay(Yoga.DISPLAY_NONE);
root_child1.setPosition(Edge.Top, 10);
root_child1.setDisplay(Display.None);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -337,7 +355,7 @@ test('display_none_with_position', () => {
expect(root_child1.getComputedWidth()).toBe(0);
expect(root_child1.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -365,8 +383,8 @@ test('display_none_with_position_absolute', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -374,12 +392,12 @@ test('display_none_with_position_absolute', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setWidth(100);
root_child0.setHeight(100);
root_child0.setDisplay(Yoga.DISPLAY_NONE);
root_child0.setDisplay(Display.None);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -391,7 +409,7 @@ test('display_none_with_position_absolute', () => {
expect(root_child0.getComputedWidth()).toBe(0);
expect(root_child0.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

74
javascript/tests/generated/YGFlexDirectionTest.test.js → javascript/tests/generated/YGFlexDirectionTest.test.ts
View File

@@ -7,12 +7,30 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGFlexDirectionTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('flex_direction_column_no_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -29,7 +47,7 @@ test('flex_direction_column_no_height', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -51,7 +69,7 @@ test('flex_direction_column_no_height', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -84,12 +102,12 @@ test('flex_direction_row_no_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
@@ -103,7 +121,7 @@ test('flex_direction_row_no_width', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -125,7 +143,7 @@ test('flex_direction_row_no_width', () => {
expect(root_child2.getComputedWidth()).toBe(10);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -158,8 +176,8 @@ test('flex_direction_column', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -177,7 +195,7 @@ test('flex_direction_column', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -199,7 +217,7 @@ test('flex_direction_column', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -232,12 +250,12 @@ test('flex_direction_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
@@ -252,7 +270,7 @@ test('flex_direction_row', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -274,7 +292,7 @@ test('flex_direction_row', () => {
expect(root_child2.getComputedWidth()).toBe(10);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -307,12 +325,12 @@ test('flex_direction_column_reverse', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_COLUMN_REVERSE);
root.setFlexDirection(FlexDirection.ColumnReverse);
root.setWidth(100);
root.setHeight(100);
@@ -327,7 +345,7 @@ test('flex_direction_column_reverse', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -349,7 +367,7 @@ test('flex_direction_column_reverse', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -382,12 +400,12 @@ test('flex_direction_row_reverse', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW_REVERSE);
root.setFlexDirection(FlexDirection.RowReverse);
root.setWidth(100);
root.setHeight(100);
@@ -402,7 +420,7 @@ test('flex_direction_row_reverse', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -424,7 +442,7 @@ test('flex_direction_row_reverse', () => {
expect(root_child2.getComputedWidth()).toBe(10);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

106
javascript/tests/generated/YGFlexTest.test.js → javascript/tests/generated/YGFlexTest.test.ts
View File

@@ -7,12 +7,30 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGFlexTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('flex_basis_flex_grow_column', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -27,7 +45,7 @@ test('flex_basis_flex_grow_column', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexGrow(1);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -44,7 +62,7 @@ test('flex_basis_flex_grow_column', () => {
expect(root_child1.getComputedWidth()).toBe(100);
expect(root_child1.getComputedHeight()).toBe(25);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -72,12 +90,12 @@ test('flex_shrink_flex_grow_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(500);
root.setHeight(500);
@@ -92,7 +110,7 @@ test('flex_shrink_flex_grow_row', () => {
root_child1.setWidth(500);
root_child1.setHeight(100);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -109,7 +127,7 @@ test('flex_shrink_flex_grow_row', () => {
expect(root_child1.getComputedWidth()).toBe(250);
expect(root_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -137,12 +155,12 @@ test('flex_shrink_flex_grow_child_flex_shrink_other_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(500);
root.setHeight(500);
@@ -158,7 +176,7 @@ test('flex_shrink_flex_grow_child_flex_shrink_other_child', () => {
root_child1.setWidth(500);
root_child1.setHeight(100);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -175,7 +193,7 @@ test('flex_shrink_flex_grow_child_flex_shrink_other_child', () => {
expect(root_child1.getComputedWidth()).toBe(250);
expect(root_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -203,12 +221,12 @@ test('flex_basis_flex_grow_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
@@ -220,7 +238,7 @@ test('flex_basis_flex_grow_row', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexGrow(1);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -237,7 +255,7 @@ test('flex_basis_flex_grow_row', () => {
expect(root_child1.getComputedWidth()).toBe(25);
expect(root_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -265,8 +283,8 @@ test('flex_basis_flex_shrink_column', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -281,7 +299,7 @@ test('flex_basis_flex_shrink_column', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexBasis(50);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -298,7 +316,7 @@ test('flex_basis_flex_shrink_column', () => {
expect(root_child1.getComputedWidth()).toBe(100);
expect(root_child1.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -326,12 +344,12 @@ test('flex_basis_flex_shrink_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
@@ -343,7 +361,7 @@ test('flex_basis_flex_shrink_row', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexBasis(50);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -360,7 +378,7 @@ test('flex_basis_flex_shrink_row', () => {
expect(root_child1.getComputedWidth()).toBe(50);
expect(root_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -388,8 +406,8 @@ test('flex_shrink_to_zero', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -410,7 +428,7 @@ test('flex_shrink_to_zero', () => {
root_child2.setWidth(50);
root_child2.setHeight(50);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -432,7 +450,7 @@ test('flex_shrink_to_zero', () => {
expect(root_child2.getComputedWidth()).toBe(50);
expect(root_child2.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -465,8 +483,8 @@ test('flex_basis_overrides_main_size', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -488,7 +506,7 @@ test('flex_basis_overrides_main_size', () => {
root_child2.setFlexGrow(1);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -510,7 +528,7 @@ test('flex_basis_overrides_main_size', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -543,8 +561,8 @@ test('flex_grow_shrink_at_most', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -558,7 +576,7 @@ test('flex_grow_shrink_at_most', () => {
root_child0_child0.setFlexGrow(1);
root_child0_child0.setFlexShrink(1);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -575,7 +593,7 @@ test('flex_grow_shrink_at_most', () => {
expect(root_child0_child0.getComputedWidth()).toBe(100);
expect(root_child0_child0.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -603,8 +621,8 @@ test('flex_grow_less_than_factor_one', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -623,7 +641,7 @@ test('flex_grow_less_than_factor_one', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setFlexGrow(0.4);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -645,7 +663,7 @@ test('flex_grow_less_than_factor_one', () => {
expect(root_child2.getComputedWidth()).toBe(200);
expect(root_child2.getComputedHeight()).toBe(184);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

302
javascript/tests/generated/YGFlexWrapTest.test.js → javascript/tests/generated/YGFlexWrapTest.test.ts
View File

@@ -7,16 +7,34 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGFlexWrapTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('wrap_column', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexWrap(Wrap.Wrap);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
@@ -38,7 +56,7 @@ test('wrap_column', () => {
root_child3.setWidth(30);
root_child3.setHeight(30);
root.insertChild(root_child3, 3);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -65,7 +83,7 @@ test('wrap_column', () => {
expect(root_child3.getComputedWidth()).toBe(30);
expect(root_child3.getComputedHeight()).toBe(30);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -103,13 +121,13 @@ test('wrap_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
const root_child0 = Yoga.Node.create(config);
@@ -131,7 +149,7 @@ test('wrap_row', () => {
root_child3.setWidth(30);
root_child3.setHeight(30);
root.insertChild(root_child3, 3);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -158,7 +176,7 @@ test('wrap_row', () => {
expect(root_child3.getComputedWidth()).toBe(30);
expect(root_child3.getComputedHeight()).toBe(30);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -196,14 +214,14 @@ test('wrap_row_align_items_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignItems(Yoga.ALIGN_FLEX_END);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignItems(Align.FlexEnd);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
const root_child0 = Yoga.Node.create(config);
@@ -225,7 +243,7 @@ test('wrap_row_align_items_flex_end', () => {
root_child3.setWidth(30);
root_child3.setHeight(30);
root.insertChild(root_child3, 3);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -252,7 +270,7 @@ test('wrap_row_align_items_flex_end', () => {
expect(root_child3.getComputedWidth()).toBe(30);
expect(root_child3.getComputedHeight()).toBe(30);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -290,14 +308,14 @@ test('wrap_row_align_items_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignItems(Align.Center);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
const root_child0 = Yoga.Node.create(config);
@@ -319,7 +337,7 @@ test('wrap_row_align_items_center', () => {
root_child3.setWidth(30);
root_child3.setHeight(30);
root.insertChild(root_child3, 3);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -346,7 +364,7 @@ test('wrap_row_align_items_center', () => {
expect(root_child3.getComputedWidth()).toBe(30);
expect(root_child3.getComputedHeight()).toBe(30);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -384,13 +402,13 @@ test('flex_wrap_children_with_min_main_overriding_flex_basis', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
const root_child0 = Yoga.Node.create(config);
@@ -404,7 +422,7 @@ test('flex_wrap_children_with_min_main_overriding_flex_basis', () => {
root_child1.setMinWidth(55);
root_child1.setHeight(50);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -421,7 +439,7 @@ test('flex_wrap_children_with_min_main_overriding_flex_basis', () => {
expect(root_child1.getComputedWidth()).toBe(55);
expect(root_child1.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -449,16 +467,16 @@ test('flex_wrap_wrap_to_child_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setAlignItems(Yoga.ALIGN_FLEX_START);
root_child0.setFlexWrap(Yoga.WRAP_WRAP);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setAlignItems(Align.FlexStart);
root_child0.setFlexWrap(Wrap.Wrap);
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
@@ -474,7 +492,7 @@ test('flex_wrap_wrap_to_child_height', () => {
root_child1.setWidth(100);
root_child1.setHeight(100);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -501,7 +519,7 @@ test('flex_wrap_wrap_to_child_height', () => {
expect(root_child1.getComputedWidth()).toBe(100);
expect(root_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -539,13 +557,13 @@ test('flex_wrap_align_stretch_fits_one_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(150);
root.setHeight(100);
@@ -556,7 +574,7 @@ test('flex_wrap_align_stretch_fits_one_row', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setWidth(50);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -573,7 +591,7 @@ test('flex_wrap_align_stretch_fits_one_row', () => {
expect(root_child1.getComputedWidth()).toBe(50);
expect(root_child1.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -601,13 +619,13 @@ test('wrap_reverse_row_align_content_flex_start', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.WrapReverse);
root.setWidth(100);
const root_child0 = Yoga.Node.create(config);
@@ -634,7 +652,7 @@ test('wrap_reverse_row_align_content_flex_start', () => {
root_child4.setWidth(30);
root_child4.setHeight(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -666,7 +684,7 @@ test('wrap_reverse_row_align_content_flex_start', () => {
expect(root_child4.getComputedWidth()).toBe(30);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -709,14 +727,14 @@ test('wrap_reverse_row_align_content_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_CENTER);
root.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Center);
root.setFlexWrap(Wrap.WrapReverse);
root.setWidth(100);
const root_child0 = Yoga.Node.create(config);
@@ -743,7 +761,7 @@ test('wrap_reverse_row_align_content_center', () => {
root_child4.setWidth(30);
root_child4.setHeight(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -775,7 +793,7 @@ test('wrap_reverse_row_align_content_center', () => {
expect(root_child4.getComputedWidth()).toBe(30);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -818,13 +836,13 @@ test('wrap_reverse_row_single_line_different_size', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.WrapReverse);
root.setWidth(300);
const root_child0 = Yoga.Node.create(config);
@@ -851,7 +869,7 @@ test('wrap_reverse_row_single_line_different_size', () => {
root_child4.setWidth(30);
root_child4.setHeight(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -883,7 +901,7 @@ test('wrap_reverse_row_single_line_different_size', () => {
expect(root_child4.getComputedWidth()).toBe(30);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -926,14 +944,14 @@ test('wrap_reverse_row_align_content_stretch', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.WrapReverse);
root.setWidth(100);
const root_child0 = Yoga.Node.create(config);
@@ -960,7 +978,7 @@ test('wrap_reverse_row_align_content_stretch', () => {
root_child4.setWidth(30);
root_child4.setHeight(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -992,7 +1010,7 @@ test('wrap_reverse_row_align_content_stretch', () => {
expect(root_child4.getComputedWidth()).toBe(30);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1035,14 +1053,14 @@ test('wrap_reverse_row_align_content_space_around', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_SPACE_AROUND);
root.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.SpaceAround);
root.setFlexWrap(Wrap.WrapReverse);
root.setWidth(100);
const root_child0 = Yoga.Node.create(config);
@@ -1069,7 +1087,7 @@ test('wrap_reverse_row_align_content_space_around', () => {
root_child4.setWidth(30);
root_child4.setHeight(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1101,7 +1119,7 @@ test('wrap_reverse_row_align_content_space_around', () => {
expect(root_child4.getComputedWidth()).toBe(30);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1144,13 +1162,13 @@ test('wrap_reverse_column_fixed_size', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
root.setAlignItems(Align.Center);
root.setFlexWrap(Wrap.WrapReverse);
root.setWidth(200);
root.setHeight(100);
@@ -1178,7 +1196,7 @@ test('wrap_reverse_column_fixed_size', () => {
root_child4.setWidth(30);
root_child4.setHeight(50);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1210,7 +1228,7 @@ test('wrap_reverse_column_fixed_size', () => {
expect(root_child4.getComputedWidth()).toBe(30);
expect(root_child4.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1253,18 +1271,18 @@ test('wrapped_row_within_align_items_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setAlignItems(Align.Center);
root.setWidth(200);
root.setHeight(200);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setFlexWrap(Yoga.WRAP_WRAP);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setFlexWrap(Wrap.Wrap);
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
@@ -1276,7 +1294,7 @@ test('wrapped_row_within_align_items_center', () => {
root_child0_child1.setWidth(80);
root_child0_child1.setHeight(80);
root_child0.insertChild(root_child0_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1298,7 +1316,7 @@ test('wrapped_row_within_align_items_center', () => {
expect(root_child0_child1.getComputedWidth()).toBe(80);
expect(root_child0_child1.getComputedHeight()).toBe(80);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1331,18 +1349,18 @@ test('wrapped_row_within_align_items_flex_start', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignItems(Yoga.ALIGN_FLEX_START);
root.setAlignItems(Align.FlexStart);
root.setWidth(200);
root.setHeight(200);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setFlexWrap(Yoga.WRAP_WRAP);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setFlexWrap(Wrap.Wrap);
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
@@ -1354,7 +1372,7 @@ test('wrapped_row_within_align_items_flex_start', () => {
root_child0_child1.setWidth(80);
root_child0_child1.setHeight(80);
root_child0.insertChild(root_child0_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1376,7 +1394,7 @@ test('wrapped_row_within_align_items_flex_start', () => {
expect(root_child0_child1.getComputedWidth()).toBe(80);
expect(root_child0_child1.getComputedHeight()).toBe(80);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1409,18 +1427,18 @@ test('wrapped_row_within_align_items_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignItems(Yoga.ALIGN_FLEX_END);
root.setAlignItems(Align.FlexEnd);
root.setWidth(200);
root.setHeight(200);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setFlexWrap(Yoga.WRAP_WRAP);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setFlexWrap(Wrap.Wrap);
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
@@ -1432,7 +1450,7 @@ test('wrapped_row_within_align_items_flex_end', () => {
root_child0_child1.setWidth(80);
root_child0_child1.setHeight(80);
root_child0.insertChild(root_child0_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1454,7 +1472,7 @@ test('wrapped_row_within_align_items_flex_end', () => {
expect(root_child0_child1.getComputedWidth()).toBe(80);
expect(root_child0_child1.getComputedHeight()).toBe(80);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1487,15 +1505,15 @@ test('wrapped_column_max_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignContent(Yoga.ALIGN_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setJustifyContent(Justify.Center);
root.setAlignContent(Align.Center);
root.setAlignItems(Align.Center);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(700);
root.setHeight(500);
@@ -1506,10 +1524,10 @@ test('wrapped_column_max_height', () => {
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setMargin(Yoga.EDGE_LEFT, 20);
root_child1.setMargin(Yoga.EDGE_TOP, 20);
root_child1.setMargin(Yoga.EDGE_RIGHT, 20);
root_child1.setMargin(Yoga.EDGE_BOTTOM, 20);
root_child1.setMargin(Edge.Left, 20);
root_child1.setMargin(Edge.Top, 20);
root_child1.setMargin(Edge.Right, 20);
root_child1.setMargin(Edge.Bottom, 20);
root_child1.setWidth(200);
root_child1.setHeight(200);
root.insertChild(root_child1, 1);
@@ -1518,7 +1536,7 @@ test('wrapped_column_max_height', () => {
root_child2.setWidth(100);
root_child2.setHeight(100);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1540,7 +1558,7 @@ test('wrapped_column_max_height', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1573,15 +1591,15 @@ test('wrapped_column_max_height_flex', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignContent(Yoga.ALIGN_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setJustifyContent(Justify.Center);
root.setAlignContent(Align.Center);
root.setAlignItems(Align.Center);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(700);
root.setHeight(500);
@@ -1598,10 +1616,10 @@ test('wrapped_column_max_height_flex', () => {
root_child1.setFlexGrow(1);
root_child1.setFlexShrink(1);
root_child1.setFlexBasis("0%");
root_child1.setMargin(Yoga.EDGE_LEFT, 20);
root_child1.setMargin(Yoga.EDGE_TOP, 20);
root_child1.setMargin(Yoga.EDGE_RIGHT, 20);
root_child1.setMargin(Yoga.EDGE_BOTTOM, 20);
root_child1.setMargin(Edge.Left, 20);
root_child1.setMargin(Edge.Top, 20);
root_child1.setMargin(Edge.Right, 20);
root_child1.setMargin(Edge.Bottom, 20);
root_child1.setWidth(200);
root_child1.setHeight(200);
root.insertChild(root_child1, 1);
@@ -1610,7 +1628,7 @@ test('wrapped_column_max_height_flex', () => {
root_child2.setWidth(100);
root_child2.setHeight(100);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1632,7 +1650,7 @@ test('wrapped_column_max_height_flex', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1665,8 +1683,8 @@ test('wrap_nodes_with_content_sizing_overflowing_margin', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -1674,8 +1692,8 @@ test('wrap_nodes_with_content_sizing_overflowing_margin', () => {
root.setHeight(500);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setFlexWrap(Yoga.WRAP_WRAP);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setFlexWrap(Wrap.Wrap);
root_child0.setWidth(85);
root.insertChild(root_child0, 0);
@@ -1688,14 +1706,14 @@ test('wrap_nodes_with_content_sizing_overflowing_margin', () => {
root_child0_child0.insertChild(root_child0_child0_child0, 0);
const root_child0_child1 = Yoga.Node.create(config);
root_child0_child1.setMargin(Yoga.EDGE_RIGHT, 10);
root_child0_child1.setMargin(Edge.Right, 10);
root_child0.insertChild(root_child0_child1, 1);
const root_child0_child1_child0 = Yoga.Node.create(config);
root_child0_child1_child0.setWidth(40);
root_child0_child1_child0.setHeight(40);
root_child0_child1.insertChild(root_child0_child1_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1727,7 +1745,7 @@ test('wrap_nodes_with_content_sizing_overflowing_margin', () => {
expect(root_child0_child1_child0.getComputedWidth()).toBe(40);
expect(root_child0_child1_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1770,8 +1788,8 @@ test('wrap_nodes_with_content_sizing_margin_cross', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -1779,8 +1797,8 @@ test('wrap_nodes_with_content_sizing_margin_cross', () => {
root.setHeight(500);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setFlexWrap(Yoga.WRAP_WRAP);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setFlexWrap(Wrap.Wrap);
root_child0.setWidth(70);
root.insertChild(root_child0, 0);
@@ -1793,14 +1811,14 @@ test('wrap_nodes_with_content_sizing_margin_cross', () => {
root_child0_child0.insertChild(root_child0_child0_child0, 0);
const root_child0_child1 = Yoga.Node.create(config);
root_child0_child1.setMargin(Yoga.EDGE_TOP, 10);
root_child0_child1.setMargin(Edge.Top, 10);
root_child0.insertChild(root_child0_child1, 1);
const root_child0_child1_child0 = Yoga.Node.create(config);
root_child0_child1_child0.setWidth(40);
root_child0_child1_child0.setHeight(40);
root_child0_child1.insertChild(root_child0_child1_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1832,7 +1850,7 @@ test('wrap_nodes_with_content_sizing_margin_cross', () => {
expect(root_child0_child1_child0.getComputedWidth()).toBe(40);
expect(root_child0_child1_child0.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

388
javascript/tests/generated/YGGapTest.test.js → javascript/tests/generated/YGGapTest.test.ts
View File

@@ -7,20 +7,38 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGGapTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('column_gap_flexible', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(80);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Yoga.GUTTER_ROW, 20);
root.setGap(Gutter.Column, 10);
root.setGap(Gutter.Row, 20);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexGrow(1);
@@ -39,7 +57,7 @@ test('column_gap_flexible', () => {
root_child2.setFlexShrink(1);
root_child2.setFlexBasis("0%");
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -61,7 +79,7 @@ test('column_gap_flexible', () => {
expect(root_child2.getComputedWidth()).toBe(20);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -94,15 +112,15 @@ test('column_gap_inflexible', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(80);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Gutter.Column, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -115,7 +133,7 @@ test('column_gap_inflexible', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(20);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -137,7 +155,7 @@ test('column_gap_inflexible', () => {
expect(root_child2.getComputedWidth()).toBe(20);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -170,15 +188,15 @@ test('column_gap_mixed_flexible', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(80);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Gutter.Column, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -193,7 +211,7 @@ test('column_gap_mixed_flexible', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(20);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -215,7 +233,7 @@ test('column_gap_mixed_flexible', () => {
expect(root_child2.getComputedWidth()).toBe(20);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -248,40 +266,40 @@ test('column_gap_child_margins', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(80);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Gutter.Column, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexGrow(1);
root_child0.setFlexShrink(1);
root_child0.setFlexBasis("0%");
root_child0.setMargin(Yoga.EDGE_LEFT, 2);
root_child0.setMargin(Yoga.EDGE_RIGHT, 2);
root_child0.setMargin(Edge.Left, 2);
root_child0.setMargin(Edge.Right, 2);
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexGrow(1);
root_child1.setFlexShrink(1);
root_child1.setFlexBasis("0%");
root_child1.setMargin(Yoga.EDGE_LEFT, 10);
root_child1.setMargin(Yoga.EDGE_RIGHT, 10);
root_child1.setMargin(Edge.Left, 10);
root_child1.setMargin(Edge.Right, 10);
root.insertChild(root_child1, 1);
const root_child2 = Yoga.Node.create(config);
root_child2.setFlexGrow(1);
root_child2.setFlexShrink(1);
root_child2.setFlexBasis("0%");
root_child2.setMargin(Yoga.EDGE_LEFT, 15);
root_child2.setMargin(Yoga.EDGE_RIGHT, 15);
root_child2.setMargin(Edge.Left, 15);
root_child2.setMargin(Edge.Right, 15);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -303,7 +321,7 @@ test('column_gap_child_margins', () => {
expect(root_child2.getComputedWidth()).toBe(2);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -336,16 +354,16 @@ test('column_row_gap_wrapping', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(80);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Yoga.GUTTER_ROW, 20);
root.setGap(Gutter.Column, 10);
root.setGap(Gutter.Row, 20);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -391,7 +409,7 @@ test('column_row_gap_wrapping', () => {
root_child8.setWidth(20);
root_child8.setHeight(20);
root.insertChild(root_child8, 8);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -443,7 +461,7 @@ test('column_row_gap_wrapping', () => {
expect(root_child8.getComputedWidth()).toBe(20);
expect(root_child8.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -506,15 +524,15 @@ test('column_gap_justify_flex_start', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Gutter.Column, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -527,7 +545,7 @@ test('column_gap_justify_flex_start', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(20);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -549,7 +567,7 @@ test('column_gap_justify_flex_start', () => {
expect(root_child2.getComputedWidth()).toBe(20);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -582,16 +600,16 @@ test('column_gap_justify_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.Center);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Gutter.Column, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -604,7 +622,7 @@ test('column_gap_justify_center', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(20);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -626,7 +644,7 @@ test('column_gap_justify_center', () => {
expect(root_child2.getComputedWidth()).toBe(20);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -659,16 +677,16 @@ test('column_gap_justify_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_FLEX_END);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.FlexEnd);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Gutter.Column, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -681,7 +699,7 @@ test('column_gap_justify_flex_end', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(20);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -703,7 +721,7 @@ test('column_gap_justify_flex_end', () => {
expect(root_child2.getComputedWidth()).toBe(20);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -736,16 +754,16 @@ test('column_gap_justify_space_between', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_SPACE_BETWEEN);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.SpaceBetween);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Gutter.Column, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -758,7 +776,7 @@ test('column_gap_justify_space_between', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(20);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -780,7 +798,7 @@ test('column_gap_justify_space_between', () => {
expect(root_child2.getComputedWidth()).toBe(20);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -813,16 +831,16 @@ test('column_gap_justify_space_around', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_SPACE_AROUND);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.SpaceAround);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Gutter.Column, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -835,7 +853,7 @@ test('column_gap_justify_space_around', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(20);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -857,7 +875,7 @@ test('column_gap_justify_space_around', () => {
expect(root_child2.getComputedWidth()).toBe(20);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -890,16 +908,16 @@ test('column_gap_justify_space_evenly', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_SPACE_EVENLY);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.SpaceEvenly);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Gutter.Column, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -912,7 +930,7 @@ test('column_gap_justify_space_evenly', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(20);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -934,7 +952,7 @@ test('column_gap_justify_space_evenly', () => {
expect(root_child2.getComputedWidth()).toBe(20);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -967,17 +985,17 @@ test('column_gap_wrap_align_flex_start', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Yoga.GUTTER_ROW, 20);
root.setGap(Gutter.Column, 10);
root.setGap(Gutter.Row, 20);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -1008,7 +1026,7 @@ test('column_gap_wrap_align_flex_start', () => {
root_child5.setWidth(20);
root_child5.setHeight(20);
root.insertChild(root_child5, 5);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1045,7 +1063,7 @@ test('column_gap_wrap_align_flex_start', () => {
expect(root_child5.getComputedWidth()).toBe(20);
expect(root_child5.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1093,18 +1111,18 @@ test('column_gap_wrap_align_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_CENTER);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Center);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Yoga.GUTTER_ROW, 20);
root.setGap(Gutter.Column, 10);
root.setGap(Gutter.Row, 20);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -1135,7 +1153,7 @@ test('column_gap_wrap_align_center', () => {
root_child5.setWidth(20);
root_child5.setHeight(20);
root.insertChild(root_child5, 5);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1172,7 +1190,7 @@ test('column_gap_wrap_align_center', () => {
expect(root_child5.getComputedWidth()).toBe(20);
expect(root_child5.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1220,18 +1238,18 @@ test('column_gap_wrap_align_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_FLEX_END);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.FlexEnd);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Yoga.GUTTER_ROW, 20);
root.setGap(Gutter.Column, 10);
root.setGap(Gutter.Row, 20);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -1262,7 +1280,7 @@ test('column_gap_wrap_align_flex_end', () => {
root_child5.setWidth(20);
root_child5.setHeight(20);
root.insertChild(root_child5, 5);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1299,7 +1317,7 @@ test('column_gap_wrap_align_flex_end', () => {
expect(root_child5.getComputedWidth()).toBe(20);
expect(root_child5.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1347,18 +1365,18 @@ test('column_gap_wrap_align_space_between', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_SPACE_BETWEEN);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.SpaceBetween);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Yoga.GUTTER_ROW, 20);
root.setGap(Gutter.Column, 10);
root.setGap(Gutter.Row, 20);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -1389,7 +1407,7 @@ test('column_gap_wrap_align_space_between', () => {
root_child5.setWidth(20);
root_child5.setHeight(20);
root.insertChild(root_child5, 5);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1426,7 +1444,7 @@ test('column_gap_wrap_align_space_between', () => {
expect(root_child5.getComputedWidth()).toBe(20);
expect(root_child5.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1474,18 +1492,18 @@ test('column_gap_wrap_align_space_around', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_SPACE_AROUND);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.SpaceAround);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Yoga.GUTTER_ROW, 20);
root.setGap(Gutter.Column, 10);
root.setGap(Gutter.Row, 20);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -1516,7 +1534,7 @@ test('column_gap_wrap_align_space_around', () => {
root_child5.setWidth(20);
root_child5.setHeight(20);
root.insertChild(root_child5, 5);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1553,7 +1571,7 @@ test('column_gap_wrap_align_space_around', () => {
expect(root_child5.getComputedWidth()).toBe(20);
expect(root_child5.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1601,17 +1619,17 @@ test('column_gap_wrap_align_stretch', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(300);
root.setHeight(300);
root.setGap(Yoga.GUTTER_COLUMN, 5);
root.setGap(Gutter.Column, 5);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexGrow(1);
@@ -1637,7 +1655,7 @@ test('column_gap_wrap_align_stretch', () => {
root_child4.setFlexGrow(1);
root_child4.setMinWidth(60);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1669,7 +1687,7 @@ test('column_gap_wrap_align_stretch', () => {
expect(root_child4.getComputedWidth()).toBe(300);
expect(root_child4.getComputedHeight()).toBe(150);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1712,14 +1730,14 @@ test('column_gap_determines_parent_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setHeight(100);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Gutter.Column, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(10);
@@ -1732,7 +1750,7 @@ test('column_gap_determines_parent_width', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(30);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1754,7 +1772,7 @@ test('column_gap_determines_parent_width', () => {
expect(root_child2.getComputedWidth()).toBe(30);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1787,18 +1805,18 @@ test('row_gap_align_items_stretch', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignContent(Align.Stretch);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(200);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Yoga.GUTTER_ROW, 20);
root.setGap(Gutter.Column, 10);
root.setGap(Gutter.Row, 20);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -1823,7 +1841,7 @@ test('row_gap_align_items_stretch', () => {
const root_child5 = Yoga.Node.create(config);
root_child5.setWidth(20);
root.insertChild(root_child5, 5);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1860,7 +1878,7 @@ test('row_gap_align_items_stretch', () => {
expect(root_child5.getComputedWidth()).toBe(20);
expect(root_child5.getComputedHeight()).toBe(90);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1908,18 +1926,18 @@ test('row_gap_align_items_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignItems(Yoga.ALIGN_FLEX_END);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setAlignItems(Align.FlexEnd);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(200);
root.setGap(Yoga.GUTTER_COLUMN, 10);
root.setGap(Yoga.GUTTER_ROW, 20);
root.setGap(Gutter.Column, 10);
root.setGap(Gutter.Row, 20);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
@@ -1944,7 +1962,7 @@ test('row_gap_align_items_end', () => {
const root_child5 = Yoga.Node.create(config);
root_child5.setWidth(20);
root.insertChild(root_child5, 5);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1981,7 +1999,7 @@ test('row_gap_align_items_end', () => {
expect(root_child5.getComputedWidth()).toBe(20);
expect(root_child5.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -2029,39 +2047,39 @@ test('row_gap_column_child_margins', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setWidth(100);
root.setHeight(200);
root.setGap(Yoga.GUTTER_ROW, 10);
root.setGap(Gutter.Row, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexGrow(1);
root_child0.setFlexShrink(1);
root_child0.setFlexBasis("0%");
root_child0.setMargin(Yoga.EDGE_TOP, 2);
root_child0.setMargin(Yoga.EDGE_BOTTOM, 2);
root_child0.setMargin(Edge.Top, 2);
root_child0.setMargin(Edge.Bottom, 2);
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexGrow(1);
root_child1.setFlexShrink(1);
root_child1.setFlexBasis("0%");
root_child1.setMargin(Yoga.EDGE_TOP, 10);
root_child1.setMargin(Yoga.EDGE_BOTTOM, 10);
root_child1.setMargin(Edge.Top, 10);
root_child1.setMargin(Edge.Bottom, 10);
root.insertChild(root_child1, 1);
const root_child2 = Yoga.Node.create(config);
root_child2.setFlexGrow(1);
root_child2.setFlexShrink(1);
root_child2.setFlexBasis("0%");
root_child2.setMargin(Yoga.EDGE_TOP, 15);
root_child2.setMargin(Yoga.EDGE_BOTTOM, 15);
root_child2.setMargin(Edge.Top, 15);
root_child2.setMargin(Edge.Bottom, 15);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -2083,7 +2101,7 @@ test('row_gap_column_child_margins', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(42);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -2116,35 +2134,35 @@ test('row_gap_row_wrap_child_margins', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexWrap(Yoga.WRAP_WRAP);
root.setFlexDirection(FlexDirection.Row);
root.setFlexWrap(Wrap.Wrap);
root.setWidth(100);
root.setHeight(200);
root.setGap(Yoga.GUTTER_ROW, 10);
root.setGap(Gutter.Row, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setMargin(Yoga.EDGE_TOP, 2);
root_child0.setMargin(Yoga.EDGE_BOTTOM, 2);
root_child0.setMargin(Edge.Top, 2);
root_child0.setMargin(Edge.Bottom, 2);
root_child0.setWidth(60);
root.insertChild(root_child0, 0);
const root_child1 = Yoga.Node.create(config);
root_child1.setMargin(Yoga.EDGE_TOP, 10);
root_child1.setMargin(Yoga.EDGE_BOTTOM, 10);
root_child1.setMargin(Edge.Top, 10);
root_child1.setMargin(Edge.Bottom, 10);
root_child1.setWidth(60);
root.insertChild(root_child1, 1);
const root_child2 = Yoga.Node.create(config);
root_child2.setMargin(Yoga.EDGE_TOP, 15);
root_child2.setMargin(Yoga.EDGE_BOTTOM, 15);
root_child2.setMargin(Edge.Top, 15);
root_child2.setMargin(Edge.Bottom, 15);
root_child2.setWidth(60);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -2166,7 +2184,7 @@ test('row_gap_row_wrap_child_margins', () => {
expect(root_child2.getComputedWidth()).toBe(60);
expect(root_child2.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -2199,13 +2217,13 @@ test('row_gap_determines_parent_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setWidth(100);
root.setGap(Yoga.GUTTER_ROW, 10);
root.setGap(Gutter.Row, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setHeight(10);
@@ -2218,7 +2236,7 @@ test('row_gap_determines_parent_height', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(30);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -2240,7 +2258,7 @@ test('row_gap_determines_parent_height', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(30);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

254
javascript/tests/generated/YGJustifyContentTest.test.js → javascript/tests/generated/YGJustifyContentTest.test.ts
View File

@@ -7,16 +7,34 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGJustifyContentTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('justify_content_row_flex_start', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(102);
root.setHeight(102);
@@ -31,7 +49,7 @@ test('justify_content_row_flex_start', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -53,7 +71,7 @@ test('justify_content_row_flex_start', () => {
expect(root_child2.getComputedWidth()).toBe(10);
expect(root_child2.getComputedHeight()).toBe(102);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -86,13 +104,13 @@ test('justify_content_row_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_FLEX_END);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.FlexEnd);
root.setWidth(102);
root.setHeight(102);
@@ -107,7 +125,7 @@ test('justify_content_row_flex_end', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -129,7 +147,7 @@ test('justify_content_row_flex_end', () => {
expect(root_child2.getComputedWidth()).toBe(10);
expect(root_child2.getComputedHeight()).toBe(102);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -162,13 +180,13 @@ test('justify_content_row_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.Center);
root.setWidth(102);
root.setHeight(102);
@@ -183,7 +201,7 @@ test('justify_content_row_center', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -205,7 +223,7 @@ test('justify_content_row_center', () => {
expect(root_child2.getComputedWidth()).toBe(10);
expect(root_child2.getComputedHeight()).toBe(102);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -238,13 +256,13 @@ test('justify_content_row_space_between', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_SPACE_BETWEEN);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.SpaceBetween);
root.setWidth(102);
root.setHeight(102);
@@ -259,7 +277,7 @@ test('justify_content_row_space_between', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -281,7 +299,7 @@ test('justify_content_row_space_between', () => {
expect(root_child2.getComputedWidth()).toBe(10);
expect(root_child2.getComputedHeight()).toBe(102);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -314,13 +332,13 @@ test('justify_content_row_space_around', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_SPACE_AROUND);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.SpaceAround);
root.setWidth(102);
root.setHeight(102);
@@ -335,7 +353,7 @@ test('justify_content_row_space_around', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -357,7 +375,7 @@ test('justify_content_row_space_around', () => {
expect(root_child2.getComputedWidth()).toBe(10);
expect(root_child2.getComputedHeight()).toBe(102);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -390,8 +408,8 @@ test('justify_content_column_flex_start', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -409,7 +427,7 @@ test('justify_content_column_flex_start', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -431,7 +449,7 @@ test('justify_content_column_flex_start', () => {
expect(root_child2.getComputedWidth()).toBe(102);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -464,12 +482,12 @@ test('justify_content_column_flex_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_FLEX_END);
root.setJustifyContent(Justify.FlexEnd);
root.setWidth(102);
root.setHeight(102);
@@ -484,7 +502,7 @@ test('justify_content_column_flex_end', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -506,7 +524,7 @@ test('justify_content_column_flex_end', () => {
expect(root_child2.getComputedWidth()).toBe(102);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -539,12 +557,12 @@ test('justify_content_column_center', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setJustifyContent(Justify.Center);
root.setWidth(102);
root.setHeight(102);
@@ -559,7 +577,7 @@ test('justify_content_column_center', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -581,7 +599,7 @@ test('justify_content_column_center', () => {
expect(root_child2.getComputedWidth()).toBe(102);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -614,12 +632,12 @@ test('justify_content_column_space_between', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_SPACE_BETWEEN);
root.setJustifyContent(Justify.SpaceBetween);
root.setWidth(102);
root.setHeight(102);
@@ -634,7 +652,7 @@ test('justify_content_column_space_between', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -656,7 +674,7 @@ test('justify_content_column_space_between', () => {
expect(root_child2.getComputedWidth()).toBe(102);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -689,12 +707,12 @@ test('justify_content_column_space_around', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_SPACE_AROUND);
root.setJustifyContent(Justify.SpaceAround);
root.setWidth(102);
root.setHeight(102);
@@ -709,7 +727,7 @@ test('justify_content_column_space_around', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -731,7 +749,7 @@ test('justify_content_column_space_around', () => {
expect(root_child2.getComputedWidth()).toBe(102);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -764,21 +782,21 @@ test('justify_content_row_min_width_and_margin', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setMargin(Yoga.EDGE_LEFT, 100);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.Center);
root.setMargin(Edge.Left, 100);
root.setMinWidth(50);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
root_child0.setHeight(20);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(100);
expect(root.getComputedTop()).toBe(0);
@@ -790,7 +808,7 @@ test('justify_content_row_min_width_and_margin', () => {
expect(root_child0.getComputedWidth()).toBe(20);
expect(root_child0.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(100);
expect(root.getComputedTop()).toBe(0);
@@ -813,14 +831,14 @@ test('justify_content_row_max_width_and_margin', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setMargin(Yoga.EDGE_LEFT, 100);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.Center);
root.setMargin(Edge.Left, 100);
root.setWidth(100);
root.setMaxWidth(80);
@@ -828,7 +846,7 @@ test('justify_content_row_max_width_and_margin', () => {
root_child0.setWidth(20);
root_child0.setHeight(20);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(100);
expect(root.getComputedTop()).toBe(0);
@@ -840,7 +858,7 @@ test('justify_content_row_max_width_and_margin', () => {
expect(root_child0.getComputedWidth()).toBe(20);
expect(root_child0.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(100);
expect(root.getComputedTop()).toBe(0);
@@ -863,20 +881,20 @@ test('justify_content_column_min_height_and_margin', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setMargin(Yoga.EDGE_TOP, 100);
root.setJustifyContent(Justify.Center);
root.setMargin(Edge.Top, 100);
root.setMinHeight(50);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(20);
root_child0.setHeight(20);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(100);
@@ -888,7 +906,7 @@ test('justify_content_column_min_height_and_margin', () => {
expect(root_child0.getComputedWidth()).toBe(20);
expect(root_child0.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(100);
@@ -911,13 +929,13 @@ test('justify_content_colunn_max_height_and_margin', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setMargin(Yoga.EDGE_TOP, 100);
root.setJustifyContent(Justify.Center);
root.setMargin(Edge.Top, 100);
root.setHeight(100);
root.setMaxHeight(80);
@@ -925,7 +943,7 @@ test('justify_content_colunn_max_height_and_margin', () => {
root_child0.setWidth(20);
root_child0.setHeight(20);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(100);
@@ -937,7 +955,7 @@ test('justify_content_colunn_max_height_and_margin', () => {
expect(root_child0.getComputedWidth()).toBe(20);
expect(root_child0.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(100);
@@ -960,12 +978,12 @@ test('justify_content_column_space_evenly', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_SPACE_EVENLY);
root.setJustifyContent(Justify.SpaceEvenly);
root.setWidth(102);
root.setHeight(102);
@@ -980,7 +998,7 @@ test('justify_content_column_space_evenly', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1002,7 +1020,7 @@ test('justify_content_column_space_evenly', () => {
expect(root_child2.getComputedWidth()).toBe(102);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1035,13 +1053,13 @@ test('justify_content_row_space_evenly', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setJustifyContent(Yoga.JUSTIFY_SPACE_EVENLY);
root.setFlexDirection(FlexDirection.Row);
root.setJustifyContent(Justify.SpaceEvenly);
root.setWidth(102);
root.setHeight(102);
@@ -1056,7 +1074,7 @@ test('justify_content_row_space_evenly', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1078,7 +1096,7 @@ test('justify_content_row_space_evenly', () => {
expect(root_child2.getComputedWidth()).toBe(0);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1111,36 +1129,36 @@ test('justify_content_min_width_with_padding_child_width_greater_than_parent', (
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setAlignContent(Align.Stretch);
root.setWidth(1000);
root.setHeight(1584);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setAlignContent(Align.Stretch);
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0.setJustifyContent(Yoga.JUSTIFY_CENTER);
root_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0.setPadding(Yoga.EDGE_LEFT, 100);
root_child0_child0.setPadding(Yoga.EDGE_RIGHT, 100);
root_child0_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0.setJustifyContent(Justify.Center);
root_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0.setPadding(Edge.Left, 100);
root_child0_child0.setPadding(Edge.Right, 100);
root_child0_child0.setMinWidth(400);
root_child0.insertChild(root_child0_child0, 0);
const root_child0_child0_child0 = Yoga.Node.create(config);
root_child0_child0_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0_child0.setWidth(300);
root_child0_child0_child0.setHeight(100);
root_child0_child0.insertChild(root_child0_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1162,7 +1180,7 @@ test('justify_content_min_width_with_padding_child_width_greater_than_parent', (
expect(root_child0_child0_child0.getComputedWidth()).toBe(300);
expect(root_child0_child0_child0.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1195,36 +1213,36 @@ test('justify_content_min_width_with_padding_child_width_lower_than_parent', ()
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignContent(Yoga.ALIGN_STRETCH);
root.setAlignContent(Align.Stretch);
root.setWidth(1080);
root.setHeight(1584);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setAlignContent(Align.Stretch);
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0.setJustifyContent(Yoga.JUSTIFY_CENTER);
root_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0.setPadding(Yoga.EDGE_LEFT, 100);
root_child0_child0.setPadding(Yoga.EDGE_RIGHT, 100);
root_child0_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0.setJustifyContent(Justify.Center);
root_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0.setPadding(Edge.Left, 100);
root_child0_child0.setPadding(Edge.Right, 100);
root_child0_child0.setMinWidth(400);
root_child0.insertChild(root_child0_child0, 0);
const root_child0_child0_child0 = Yoga.Node.create(config);
root_child0_child0_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0_child0.setAlignContent(Yoga.ALIGN_STRETCH);
root_child0_child0_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0_child0.setAlignContent(Align.Stretch);
root_child0_child0_child0.setWidth(199);
root_child0_child0_child0.setHeight(100);
root_child0_child0.insertChild(root_child0_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1246,7 +1264,7 @@ test('justify_content_min_width_with_padding_child_width_lower_than_parent', ()
expect(root_child0_child0_child0.getComputedWidth()).toBe(199);
expect(root_child0_child0_child0.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

440
javascript/tests/generated/YGMarginTest.test.js → javascript/tests/generated/YGMarginTest.test.ts
View File

File diff suppressed because it is too large Load Diff

256
javascript/tests/generated/YGMinMaxDimensionTest.test.js → javascript/tests/generated/YGMinMaxDimensionTest.test.ts
View File

@@ -7,12 +7,30 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGMinMaxDimensionTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('max_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -23,7 +41,7 @@ test('max_width', () => {
root_child0.setMaxWidth(50);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -35,7 +53,7 @@ test('max_width', () => {
expect(root_child0.getComputedWidth()).toBe(50);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -58,12 +76,12 @@ test('max_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
@@ -71,7 +89,7 @@ test('max_height', () => {
root_child0.setWidth(10);
root_child0.setMaxHeight(50);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -83,7 +101,7 @@ test('max_height', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -106,8 +124,8 @@ test.skip('min_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -122,7 +140,7 @@ test.skip('min_height', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexGrow(1);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -139,7 +157,7 @@ test.skip('min_height', () => {
expect(root_child1.getComputedWidth()).toBe(100);
expect(root_child1.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -167,12 +185,12 @@ test.skip('min_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
@@ -184,7 +202,7 @@ test.skip('min_width', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setFlexGrow(1);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -201,7 +219,7 @@ test.skip('min_width', () => {
expect(root_child1.getComputedWidth()).toBe(40);
expect(root_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -229,12 +247,12 @@ test('justify_content_min_max', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setJustifyContent(Justify.Center);
root.setWidth(100);
root.setMinHeight(100);
root.setMaxHeight(200);
@@ -243,7 +261,7 @@ test('justify_content_min_max', () => {
root_child0.setWidth(60);
root_child0.setHeight(60);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -255,7 +273,7 @@ test('justify_content_min_max', () => {
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(60);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -278,12 +296,12 @@ test('align_items_min_max', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setAlignItems(Align.Center);
root.setMinWidth(100);
root.setMaxWidth(200);
root.setHeight(100);
@@ -292,7 +310,7 @@ test('align_items_min_max', () => {
root_child0.setWidth(60);
root_child0.setHeight(60);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -304,7 +322,7 @@ test('align_items_min_max', () => {
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(60);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -327,12 +345,12 @@ test('justify_content_overflow_min_max', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setJustifyContent(Justify.Center);
root.setMinHeight(100);
root.setMaxHeight(110);
@@ -350,7 +368,7 @@ test('justify_content_overflow_min_max', () => {
root_child2.setWidth(50);
root_child2.setHeight(50);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -372,7 +390,7 @@ test('justify_content_overflow_min_max', () => {
expect(root_child2.getComputedWidth()).toBe(50);
expect(root_child2.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -405,8 +423,8 @@ test('flex_grow_to_min', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -422,7 +440,7 @@ test('flex_grow_to_min', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setHeight(50);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -439,7 +457,7 @@ test('flex_grow_to_min', () => {
expect(root_child1.getComputedWidth()).toBe(100);
expect(root_child1.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -467,25 +485,25 @@ test('flex_grow_in_at_most_container', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setAlignItems(Yoga.ALIGN_FLEX_START);
root.setFlexDirection(FlexDirection.Row);
root.setAlignItems(Align.FlexStart);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setFlexDirection(FlexDirection.Row);
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setFlexGrow(1);
root_child0_child0.setFlexBasis(0);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -502,7 +520,7 @@ test('flex_grow_in_at_most_container', () => {
expect(root_child0_child0.getComputedWidth()).toBe(0);
expect(root_child0_child0.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -530,19 +548,19 @@ test('flex_grow_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexGrow(1);
root_child0.setFlexBasis(0);
root_child0.setHeight(100);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -554,7 +572,7 @@ test('flex_grow_child', () => {
expect(root_child0.getComputedWidth()).toBe(0);
expect(root_child0.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -577,8 +595,8 @@ test('flex_grow_within_constrained_min_max_column', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -592,7 +610,7 @@ test('flex_grow_within_constrained_min_max_column', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setHeight(50);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -609,7 +627,7 @@ test('flex_grow_within_constrained_min_max_column', () => {
expect(root_child1.getComputedWidth()).toBe(0);
expect(root_child1.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -637,8 +655,8 @@ test('flex_grow_within_max_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -646,7 +664,7 @@ test('flex_grow_within_max_width', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setMaxWidth(100);
root.insertChild(root_child0, 0);
@@ -654,7 +672,7 @@ test('flex_grow_within_max_width', () => {
root_child0_child0.setFlexGrow(1);
root_child0_child0.setHeight(20);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -671,7 +689,7 @@ test('flex_grow_within_max_width', () => {
expect(root_child0_child0.getComputedWidth()).toBe(100);
expect(root_child0_child0.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -699,8 +717,8 @@ test('flex_grow_within_constrained_max_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -708,7 +726,7 @@ test('flex_grow_within_constrained_max_width', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setMaxWidth(300);
root.insertChild(root_child0, 0);
@@ -716,7 +734,7 @@ test('flex_grow_within_constrained_max_width', () => {
root_child0_child0.setFlexGrow(1);
root_child0_child0.setHeight(20);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -733,7 +751,7 @@ test('flex_grow_within_constrained_max_width', () => {
expect(root_child0_child0.getComputedWidth()).toBe(200);
expect(root_child0_child0.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -761,8 +779,8 @@ test('flex_root_ignored', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -779,7 +797,7 @@ test('flex_root_ignored', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setHeight(100);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -796,7 +814,7 @@ test('flex_root_ignored', () => {
expect(root_child1.getComputedWidth()).toBe(100);
expect(root_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -824,8 +842,8 @@ test('flex_grow_root_minimized', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -847,7 +865,7 @@ test('flex_grow_root_minimized', () => {
const root_child0_child1 = Yoga.Node.create(config);
root_child0_child1.setHeight(100);
root_child0.insertChild(root_child0_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -869,7 +887,7 @@ test('flex_grow_root_minimized', () => {
expect(root_child0_child1.getComputedWidth()).toBe(100);
expect(root_child0_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -902,8 +920,8 @@ test('flex_grow_height_maximized', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -924,7 +942,7 @@ test('flex_grow_height_maximized', () => {
const root_child0_child1 = Yoga.Node.create(config);
root_child0_child1.setHeight(100);
root_child0.insertChild(root_child0_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -946,7 +964,7 @@ test('flex_grow_height_maximized', () => {
expect(root_child0_child1.getComputedWidth()).toBe(100);
expect(root_child0_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -979,12 +997,12 @@ test('flex_grow_within_constrained_min_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setMinWidth(100);
root.setHeight(100);
@@ -995,7 +1013,7 @@ test('flex_grow_within_constrained_min_row', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setWidth(50);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1012,7 +1030,7 @@ test('flex_grow_within_constrained_min_row', () => {
expect(root_child1.getComputedWidth()).toBe(50);
expect(root_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1040,8 +1058,8 @@ test('flex_grow_within_constrained_min_column', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -1054,7 +1072,7 @@ test('flex_grow_within_constrained_min_column', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setHeight(50);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1071,7 +1089,7 @@ test('flex_grow_within_constrained_min_column', () => {
expect(root_child1.getComputedWidth()).toBe(0);
expect(root_child1.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1099,15 +1117,15 @@ test('flex_grow_within_constrained_max_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setWidth(200);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setMaxWidth(100);
root_child0.setHeight(100);
root.insertChild(root_child0, 0);
@@ -1120,7 +1138,7 @@ test('flex_grow_within_constrained_max_row', () => {
const root_child0_child1 = Yoga.Node.create(config);
root_child0_child1.setWidth(50);
root_child0.insertChild(root_child0_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1142,7 +1160,7 @@ test('flex_grow_within_constrained_max_row', () => {
expect(root_child0_child1.getComputedWidth()).toBe(50);
expect(root_child0_child1.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1175,8 +1193,8 @@ test('flex_grow_within_constrained_max_column', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -1191,7 +1209,7 @@ test('flex_grow_within_constrained_max_column', () => {
const root_child1 = Yoga.Node.create(config);
root_child1.setHeight(50);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1208,7 +1226,7 @@ test('flex_grow_within_constrained_max_column', () => {
expect(root_child1.getComputedWidth()).toBe(100);
expect(root_child1.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1236,12 +1254,12 @@ test('child_min_max_width_flexing', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(120);
root.setHeight(50);
@@ -1256,7 +1274,7 @@ test('child_min_max_width_flexing', () => {
root_child1.setFlexBasis("50%");
root_child1.setMaxWidth(20);
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1273,7 +1291,7 @@ test('child_min_max_width_flexing', () => {
expect(root_child1.getComputedWidth()).toBe(20);
expect(root_child1.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1301,21 +1319,21 @@ test('min_width_overrides_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setWidth(50);
root.setMinWidth(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
expect(root.getComputedWidth()).toBe(100);
expect(root.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1333,21 +1351,21 @@ test('max_width_overrides_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setWidth(200);
root.setMaxWidth(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
expect(root.getComputedWidth()).toBe(100);
expect(root.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1365,21 +1383,21 @@ test('min_height_overrides_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setHeight(50);
root.setMinHeight(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
expect(root.getComputedWidth()).toBe(0);
expect(root.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1397,21 +1415,21 @@ test('max_height_overrides_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setHeight(200);
root.setMaxHeight(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
expect(root.getComputedWidth()).toBe(0);
expect(root.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1429,12 +1447,12 @@ test('min_max_percent_no_width_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setAlignItems(Yoga.ALIGN_FLEX_START);
root.setAlignItems(Align.FlexStart);
root.setWidth(100);
root.setHeight(100);
@@ -1444,7 +1462,7 @@ test('min_max_percent_no_width_height', () => {
root_child0.setMinHeight("10%");
root_child0.setMaxHeight("10%");
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1456,7 +1474,7 @@ test('min_max_percent_no_width_height', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

120
javascript/tests/generated/YGPaddingTest.test.js → javascript/tests/generated/YGPaddingTest.test.ts
View File

@@ -7,27 +7,45 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGPaddingTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('padding_no_size', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setPadding(Yoga.EDGE_LEFT, 10);
root.setPadding(Yoga.EDGE_TOP, 10);
root.setPadding(Yoga.EDGE_RIGHT, 10);
root.setPadding(Yoga.EDGE_BOTTOM, 10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.setPadding(Edge.Left, 10);
root.setPadding(Edge.Top, 10);
root.setPadding(Edge.Right, 10);
root.setPadding(Edge.Bottom, 10);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
expect(root.getComputedWidth()).toBe(20);
expect(root.getComputedHeight()).toBe(20);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -45,21 +63,21 @@ test('padding_container_match_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setPadding(Yoga.EDGE_LEFT, 10);
root.setPadding(Yoga.EDGE_TOP, 10);
root.setPadding(Yoga.EDGE_RIGHT, 10);
root.setPadding(Yoga.EDGE_BOTTOM, 10);
root.setPadding(Edge.Left, 10);
root.setPadding(Edge.Top, 10);
root.setPadding(Edge.Right, 10);
root.setPadding(Edge.Bottom, 10);
const root_child0 = Yoga.Node.create(config);
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -71,7 +89,7 @@ test('padding_container_match_child', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -94,15 +112,15 @@ test('padding_flex_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setPadding(Yoga.EDGE_LEFT, 10);
root.setPadding(Yoga.EDGE_TOP, 10);
root.setPadding(Yoga.EDGE_RIGHT, 10);
root.setPadding(Yoga.EDGE_BOTTOM, 10);
root.setPadding(Edge.Left, 10);
root.setPadding(Edge.Top, 10);
root.setPadding(Edge.Right, 10);
root.setPadding(Edge.Bottom, 10);
root.setWidth(100);
root.setHeight(100);
@@ -110,7 +128,7 @@ test('padding_flex_child', () => {
root_child0.setFlexGrow(1);
root_child0.setWidth(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -122,7 +140,7 @@ test('padding_flex_child', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(80);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -145,22 +163,22 @@ test('padding_stretch_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setPadding(Yoga.EDGE_LEFT, 10);
root.setPadding(Yoga.EDGE_TOP, 10);
root.setPadding(Yoga.EDGE_RIGHT, 10);
root.setPadding(Yoga.EDGE_BOTTOM, 10);
root.setPadding(Edge.Left, 10);
root.setPadding(Edge.Top, 10);
root.setPadding(Edge.Right, 10);
root.setPadding(Edge.Bottom, 10);
root.setWidth(100);
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -172,7 +190,7 @@ test('padding_stretch_child', () => {
expect(root_child0.getComputedWidth()).toBe(80);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -195,16 +213,16 @@ test('padding_center_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setPadding(Yoga.EDGE_START, 10);
root.setPadding(Yoga.EDGE_END, 20);
root.setPadding(Yoga.EDGE_BOTTOM, 20);
root.setJustifyContent(Justify.Center);
root.setAlignItems(Align.Center);
root.setPadding(Edge.Start, 10);
root.setPadding(Edge.End, 20);
root.setPadding(Edge.Bottom, 20);
root.setWidth(100);
root.setHeight(100);
@@ -212,7 +230,7 @@ test('padding_center_child', () => {
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -224,7 +242,7 @@ test('padding_center_child', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -247,25 +265,25 @@ test('child_with_padding_align_end', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_FLEX_END);
root.setAlignItems(Yoga.ALIGN_FLEX_END);
root.setJustifyContent(Justify.FlexEnd);
root.setAlignItems(Align.FlexEnd);
root.setWidth(200);
root.setHeight(200);
const root_child0 = Yoga.Node.create(config);
root_child0.setPadding(Yoga.EDGE_LEFT, 20);
root_child0.setPadding(Yoga.EDGE_TOP, 20);
root_child0.setPadding(Yoga.EDGE_RIGHT, 20);
root_child0.setPadding(Yoga.EDGE_BOTTOM, 20);
root_child0.setPadding(Edge.Left, 20);
root_child0.setPadding(Edge.Top, 20);
root_child0.setPadding(Edge.Right, 20);
root_child0.setPadding(Edge.Bottom, 20);
root_child0.setWidth(100);
root_child0.setHeight(100);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -277,7 +295,7 @@ test('child_with_padding_align_end', () => {
expect(root_child0.getComputedWidth()).toBe(100);
expect(root_child0.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

286
javascript/tests/generated/YGPercentageTest.test.js → javascript/tests/generated/YGPercentageTest.test.ts
View File

@@ -7,16 +7,34 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGPercentageTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('percentage_width_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(200);
root.setHeight(200);
@@ -24,7 +42,7 @@ test('percentage_width_height', () => {
root_child0.setWidth("30%");
root_child0.setHeight("30%");
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -36,7 +54,7 @@ test('percentage_width_height', () => {
expect(root_child0.getComputedWidth()).toBe(60);
expect(root_child0.getComputedHeight()).toBe(60);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -59,22 +77,22 @@ test('percentage_position_left_top', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(400);
root.setHeight(400);
const root_child0 = Yoga.Node.create(config);
root_child0.setPosition(Yoga.EDGE_LEFT, "10%");
root_child0.setPosition(Yoga.EDGE_TOP, "20%");
root_child0.setPosition(Edge.Left, "10%");
root_child0.setPosition(Edge.Top, "20%");
root_child0.setWidth("45%");
root_child0.setHeight("55%");
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -86,7 +104,7 @@ test('percentage_position_left_top', () => {
expect(root_child0.getComputedWidth()).toBe(180);
expect(root_child0.getComputedHeight()).toBe(220);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -109,22 +127,22 @@ test('percentage_position_bottom_right', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(500);
root.setHeight(500);
const root_child0 = Yoga.Node.create(config);
root_child0.setPosition(Yoga.EDGE_RIGHT, "20%");
root_child0.setPosition(Yoga.EDGE_BOTTOM, "10%");
root_child0.setPosition(Edge.Right, "20%");
root_child0.setPosition(Edge.Bottom, "10%");
root_child0.setWidth("55%");
root_child0.setHeight("15%");
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -136,7 +154,7 @@ test('percentage_position_bottom_right', () => {
expect(root_child0.getComputedWidth()).toBe(275);
expect(root_child0.getComputedHeight()).toBe(75);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -159,12 +177,12 @@ test('percentage_flex_basis', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(200);
root.setHeight(200);
@@ -177,7 +195,7 @@ test('percentage_flex_basis', () => {
root_child1.setFlexGrow(1);
root_child1.setFlexBasis("25%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -194,7 +212,7 @@ test('percentage_flex_basis', () => {
expect(root_child1.getComputedWidth()).toBe(75);
expect(root_child1.getComputedHeight()).toBe(200);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -222,8 +240,8 @@ test('percentage_flex_basis_cross', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -239,7 +257,7 @@ test('percentage_flex_basis_cross', () => {
root_child1.setFlexGrow(1);
root_child1.setFlexBasis("25%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -256,7 +274,7 @@ test('percentage_flex_basis_cross', () => {
expect(root_child1.getComputedWidth()).toBe(200);
expect(root_child1.getComputedHeight()).toBe(75);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -284,8 +302,8 @@ test.skip('percentage_flex_basis_cross_min_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -301,7 +319,7 @@ test.skip('percentage_flex_basis_cross_min_height', () => {
root_child1.setFlexGrow(2);
root_child1.setMinHeight("10%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -318,7 +336,7 @@ test.skip('percentage_flex_basis_cross_min_height', () => {
expect(root_child1.getComputedWidth()).toBe(200);
expect(root_child1.getComputedHeight()).toBe(80);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -346,12 +364,12 @@ test('percentage_flex_basis_main_max_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(200);
root.setHeight(200);
@@ -366,7 +384,7 @@ test('percentage_flex_basis_main_max_height', () => {
root_child1.setFlexBasis("10%");
root_child1.setMaxHeight("20%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -383,7 +401,7 @@ test('percentage_flex_basis_main_max_height', () => {
expect(root_child1.getComputedWidth()).toBe(148);
expect(root_child1.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -411,8 +429,8 @@ test('percentage_flex_basis_cross_max_height', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -430,7 +448,7 @@ test('percentage_flex_basis_cross_max_height', () => {
root_child1.setFlexBasis("10%");
root_child1.setMaxHeight("20%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -447,7 +465,7 @@ test('percentage_flex_basis_cross_max_height', () => {
expect(root_child1.getComputedWidth()).toBe(200);
expect(root_child1.getComputedHeight()).toBe(40);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -475,12 +493,12 @@ test('percentage_flex_basis_main_max_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(200);
root.setHeight(200);
@@ -495,7 +513,7 @@ test('percentage_flex_basis_main_max_width', () => {
root_child1.setFlexBasis("10%");
root_child1.setMaxWidth("20%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -512,7 +530,7 @@ test('percentage_flex_basis_main_max_width', () => {
expect(root_child1.getComputedWidth()).toBe(40);
expect(root_child1.getComputedHeight()).toBe(200);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -540,8 +558,8 @@ test('percentage_flex_basis_cross_max_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -559,7 +577,7 @@ test('percentage_flex_basis_cross_max_width', () => {
root_child1.setFlexBasis("15%");
root_child1.setMaxWidth("20%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -576,7 +594,7 @@ test('percentage_flex_basis_cross_max_width', () => {
expect(root_child1.getComputedWidth()).toBe(40);
expect(root_child1.getComputedHeight()).toBe(150);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -604,12 +622,12 @@ test('percentage_flex_basis_main_min_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(200);
root.setHeight(200);
@@ -624,7 +642,7 @@ test('percentage_flex_basis_main_min_width', () => {
root_child1.setFlexBasis("10%");
root_child1.setMinWidth("20%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -641,7 +659,7 @@ test('percentage_flex_basis_main_min_width', () => {
expect(root_child1.getComputedWidth()).toBe(80);
expect(root_child1.getComputedHeight()).toBe(200);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -669,8 +687,8 @@ test('percentage_flex_basis_cross_min_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -688,7 +706,7 @@ test('percentage_flex_basis_cross_min_width', () => {
root_child1.setFlexBasis("15%");
root_child1.setMinWidth("20%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -705,7 +723,7 @@ test('percentage_flex_basis_cross_min_width', () => {
expect(root_child1.getComputedWidth()).toBe(200);
expect(root_child1.getComputedHeight()).toBe(150);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -733,8 +751,8 @@ test('percentage_multiple_nested_with_padding_margin_and_percentage_values', ()
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -744,38 +762,38 @@ test('percentage_multiple_nested_with_padding_margin_and_percentage_values', ()
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexGrow(1);
root_child0.setFlexBasis("10%");
root_child0.setMargin(Yoga.EDGE_LEFT, 5);
root_child0.setMargin(Yoga.EDGE_TOP, 5);
root_child0.setMargin(Yoga.EDGE_RIGHT, 5);
root_child0.setMargin(Yoga.EDGE_BOTTOM, 5);
root_child0.setPadding(Yoga.EDGE_LEFT, 3);
root_child0.setPadding(Yoga.EDGE_TOP, 3);
root_child0.setPadding(Yoga.EDGE_RIGHT, 3);
root_child0.setPadding(Yoga.EDGE_BOTTOM, 3);
root_child0.setMargin(Edge.Left, 5);
root_child0.setMargin(Edge.Top, 5);
root_child0.setMargin(Edge.Right, 5);
root_child0.setMargin(Edge.Bottom, 5);
root_child0.setPadding(Edge.Left, 3);
root_child0.setPadding(Edge.Top, 3);
root_child0.setPadding(Edge.Right, 3);
root_child0.setPadding(Edge.Bottom, 3);
root_child0.setMinWidth("60%");
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setMargin(Yoga.EDGE_LEFT, 5);
root_child0_child0.setMargin(Yoga.EDGE_TOP, 5);
root_child0_child0.setMargin(Yoga.EDGE_RIGHT, 5);
root_child0_child0.setMargin(Yoga.EDGE_BOTTOM, 5);
root_child0_child0.setPadding(Yoga.EDGE_LEFT, "3%");
root_child0_child0.setPadding(Yoga.EDGE_TOP, "3%");
root_child0_child0.setPadding(Yoga.EDGE_RIGHT, "3%");
root_child0_child0.setPadding(Yoga.EDGE_BOTTOM, "3%");
root_child0_child0.setMargin(Edge.Left, 5);
root_child0_child0.setMargin(Edge.Top, 5);
root_child0_child0.setMargin(Edge.Right, 5);
root_child0_child0.setMargin(Edge.Bottom, 5);
root_child0_child0.setPadding(Edge.Left, "3%");
root_child0_child0.setPadding(Edge.Top, "3%");
root_child0_child0.setPadding(Edge.Right, "3%");
root_child0_child0.setPadding(Edge.Bottom, "3%");
root_child0_child0.setWidth("50%");
root_child0.insertChild(root_child0_child0, 0);
const root_child0_child0_child0 = Yoga.Node.create(config);
root_child0_child0_child0.setMargin(Yoga.EDGE_LEFT, "5%");
root_child0_child0_child0.setMargin(Yoga.EDGE_TOP, "5%");
root_child0_child0_child0.setMargin(Yoga.EDGE_RIGHT, "5%");
root_child0_child0_child0.setMargin(Yoga.EDGE_BOTTOM, "5%");
root_child0_child0_child0.setPadding(Yoga.EDGE_LEFT, 3);
root_child0_child0_child0.setPadding(Yoga.EDGE_TOP, 3);
root_child0_child0_child0.setPadding(Yoga.EDGE_RIGHT, 3);
root_child0_child0_child0.setPadding(Yoga.EDGE_BOTTOM, 3);
root_child0_child0_child0.setMargin(Edge.Left, "5%");
root_child0_child0_child0.setMargin(Edge.Top, "5%");
root_child0_child0_child0.setMargin(Edge.Right, "5%");
root_child0_child0_child0.setMargin(Edge.Bottom, "5%");
root_child0_child0_child0.setPadding(Edge.Left, 3);
root_child0_child0_child0.setPadding(Edge.Top, 3);
root_child0_child0_child0.setPadding(Edge.Right, 3);
root_child0_child0_child0.setPadding(Edge.Bottom, 3);
root_child0_child0_child0.setWidth("45%");
root_child0_child0.insertChild(root_child0_child0_child0, 0);
@@ -784,7 +802,7 @@ test('percentage_multiple_nested_with_padding_margin_and_percentage_values', ()
root_child1.setFlexBasis("15%");
root_child1.setMinWidth("20%");
root.insertChild(root_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -811,7 +829,7 @@ test('percentage_multiple_nested_with_padding_margin_and_percentage_values', ()
expect(root_child1.getComputedWidth()).toBe(200);
expect(root_child1.getComputedHeight()).toBe(142);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -849,8 +867,8 @@ test('percentage_margin_should_calculate_based_only_on_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -859,17 +877,17 @@ test('percentage_margin_should_calculate_based_only_on_width', () => {
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexGrow(1);
root_child0.setMargin(Yoga.EDGE_LEFT, "10%");
root_child0.setMargin(Yoga.EDGE_TOP, "10%");
root_child0.setMargin(Yoga.EDGE_RIGHT, "10%");
root_child0.setMargin(Yoga.EDGE_BOTTOM, "10%");
root_child0.setMargin(Edge.Left, "10%");
root_child0.setMargin(Edge.Top, "10%");
root_child0.setMargin(Edge.Right, "10%");
root_child0.setMargin(Edge.Bottom, "10%");
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setWidth(10);
root_child0_child0.setHeight(10);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -886,7 +904,7 @@ test('percentage_margin_should_calculate_based_only_on_width', () => {
expect(root_child0_child0.getComputedWidth()).toBe(10);
expect(root_child0_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -914,8 +932,8 @@ test('percentage_padding_should_calculate_based_only_on_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -924,17 +942,17 @@ test('percentage_padding_should_calculate_based_only_on_width', () => {
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexGrow(1);
root_child0.setPadding(Yoga.EDGE_LEFT, "10%");
root_child0.setPadding(Yoga.EDGE_TOP, "10%");
root_child0.setPadding(Yoga.EDGE_RIGHT, "10%");
root_child0.setPadding(Yoga.EDGE_BOTTOM, "10%");
root_child0.setPadding(Edge.Left, "10%");
root_child0.setPadding(Edge.Top, "10%");
root_child0.setPadding(Edge.Right, "10%");
root_child0.setPadding(Edge.Bottom, "10%");
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setWidth(10);
root_child0_child0.setHeight(10);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -951,7 +969,7 @@ test('percentage_padding_should_calculate_based_only_on_width', () => {
expect(root_child0_child0.getComputedWidth()).toBe(10);
expect(root_child0_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -979,8 +997,8 @@ test('percentage_absolute_position', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -988,13 +1006,13 @@ test('percentage_absolute_position', () => {
root.setHeight(100);
const root_child0 = Yoga.Node.create(config);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_LEFT, "30%");
root_child0.setPosition(Yoga.EDGE_TOP, "10%");
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Left, "30%");
root_child0.setPosition(Edge.Top, "10%");
root_child0.setWidth(10);
root_child0.setHeight(10);
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1006,7 +1024,7 @@ test('percentage_absolute_position', () => {
expect(root_child0.getComputedWidth()).toBe(10);
expect(root_child0.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1029,8 +1047,8 @@ test('percentage_width_height_undefined_parent_size', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -1039,7 +1057,7 @@ test('percentage_width_height_undefined_parent_size', () => {
root_child0.setWidth("50%");
root_child0.setHeight("50%");
root.insertChild(root_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1051,7 +1069,7 @@ test('percentage_width_height_undefined_parent_size', () => {
expect(root_child0.getComputedWidth()).toBe(0);
expect(root_child0.getComputedHeight()).toBe(0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1074,12 +1092,12 @@ test('percent_within_flex_grow', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(350);
root.setHeight(100);
@@ -1098,7 +1116,7 @@ test('percent_within_flex_grow', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setWidth(100);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1125,7 +1143,7 @@ test('percent_within_flex_grow', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1163,13 +1181,13 @@ test('percentage_container_in_wrapping_container', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setJustifyContent(Yoga.JUSTIFY_CENTER);
root.setAlignItems(Yoga.ALIGN_CENTER);
root.setJustifyContent(Justify.Center);
root.setAlignItems(Align.Center);
root.setWidth(200);
root.setHeight(200);
@@ -1177,8 +1195,8 @@ test('percentage_container_in_wrapping_container', () => {
root.insertChild(root_child0, 0);
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0_child0.setJustifyContent(Yoga.JUSTIFY_CENTER);
root_child0_child0.setFlexDirection(FlexDirection.Row);
root_child0_child0.setJustifyContent(Justify.Center);
root_child0_child0.setWidth("100%");
root_child0.insertChild(root_child0_child0, 0);
@@ -1191,7 +1209,7 @@ test('percentage_container_in_wrapping_container', () => {
root_child0_child0_child1.setWidth(50);
root_child0_child0_child1.setHeight(50);
root_child0_child0.insertChild(root_child0_child0_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1218,7 +1236,7 @@ test('percentage_container_in_wrapping_container', () => {
expect(root_child0_child0_child1.getComputedWidth()).toBe(50);
expect(root_child0_child0_child1.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1256,8 +1274,8 @@ test('percent_absolute_position', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -1265,9 +1283,9 @@ test('percent_absolute_position', () => {
root.setHeight(50);
const root_child0 = Yoga.Node.create(config);
root_child0.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root_child0.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
root_child0.setPosition(Yoga.EDGE_LEFT, "50%");
root_child0.setFlexDirection(FlexDirection.Row);
root_child0.setPositionType(PositionType.Absolute);
root_child0.setPosition(Edge.Left, "50%");
root_child0.setWidth("100%");
root_child0.setHeight(50);
root.insertChild(root_child0, 0);
@@ -1279,7 +1297,7 @@ test('percent_absolute_position', () => {
const root_child0_child1 = Yoga.Node.create(config);
root_child0_child1.setWidth("100%");
root_child0.insertChild(root_child0_child1, 1);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1301,7 +1319,7 @@ test('percent_absolute_position', () => {
expect(root_child0_child1.getComputedWidth()).toBe(60);
expect(root_child0_child1.getComputedHeight()).toBe(50);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

140
javascript/tests/generated/YGRoundingTest.test.js → javascript/tests/generated/YGRoundingTest.test.ts
View File

@@ -7,16 +7,34 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGRoundingTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('rounding_flex_basis_flex_grow_row_width_of_100', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(100);
root.setHeight(100);
@@ -31,7 +49,7 @@ test('rounding_flex_basis_flex_grow_row_width_of_100', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setFlexGrow(1);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -53,7 +71,7 @@ test('rounding_flex_basis_flex_grow_row_width_of_100', () => {
expect(root_child2.getComputedWidth()).toBe(33);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -86,12 +104,12 @@ test('rounding_flex_basis_flex_grow_row_prime_number_width', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(113);
root.setHeight(100);
@@ -114,7 +132,7 @@ test('rounding_flex_basis_flex_grow_row_prime_number_width', () => {
const root_child4 = Yoga.Node.create(config);
root_child4.setFlexGrow(1);
root.insertChild(root_child4, 4);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -146,7 +164,7 @@ test('rounding_flex_basis_flex_grow_row_prime_number_width', () => {
expect(root_child4.getComputedWidth()).toBe(23);
expect(root_child4.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -189,12 +207,12 @@ test('rounding_flex_basis_flex_shrink_row', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(101);
root.setHeight(100);
@@ -210,7 +228,7 @@ test('rounding_flex_basis_flex_shrink_row', () => {
const root_child2 = Yoga.Node.create(config);
root_child2.setFlexBasis(25);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -232,7 +250,7 @@ test('rounding_flex_basis_flex_shrink_row', () => {
expect(root_child2.getComputedWidth()).toBe(25);
expect(root_child2.getComputedHeight()).toBe(100);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -265,8 +283,8 @@ test('rounding_flex_basis_overrides_main_size', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -288,7 +306,7 @@ test('rounding_flex_basis_overrides_main_size', () => {
root_child2.setFlexGrow(1);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -310,7 +328,7 @@ test('rounding_flex_basis_overrides_main_size', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(24);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -343,8 +361,8 @@ test('rounding_total_fractial', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -366,7 +384,7 @@ test('rounding_total_fractial', () => {
root_child2.setFlexGrow(1.1);
root_child2.setHeight(10.7);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -388,7 +406,7 @@ test('rounding_total_fractial', () => {
expect(root_child2.getComputedWidth()).toBe(87);
expect(root_child2.getComputedHeight()).toBe(24);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -421,8 +439,8 @@ test('rounding_total_fractial_nested', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -438,14 +456,14 @@ test('rounding_total_fractial_nested', () => {
const root_child0_child0 = Yoga.Node.create(config);
root_child0_child0.setFlexGrow(1);
root_child0_child0.setFlexBasis(0.3);
root_child0_child0.setPosition(Yoga.EDGE_BOTTOM, 13.3);
root_child0_child0.setPosition(Edge.Bottom, 13.3);
root_child0_child0.setHeight(9.9);
root_child0.insertChild(root_child0_child0, 0);
const root_child0_child1 = Yoga.Node.create(config);
root_child0_child1.setFlexGrow(4);
root_child0_child1.setFlexBasis(0.3);
root_child0_child1.setPosition(Yoga.EDGE_TOP, 13.3);
root_child0_child1.setPosition(Edge.Top, 13.3);
root_child0_child1.setHeight(1.1);
root_child0.insertChild(root_child0_child1, 1);
@@ -458,7 +476,7 @@ test('rounding_total_fractial_nested', () => {
root_child2.setFlexGrow(1.1);
root_child2.setHeight(10.7);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -490,7 +508,7 @@ test('rounding_total_fractial_nested', () => {
expect(root_child2.getComputedWidth()).toBe(87);
expect(root_child2.getComputedHeight()).toBe(24);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -533,8 +551,8 @@ test('rounding_fractial_input_1', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -556,7 +574,7 @@ test('rounding_fractial_input_1', () => {
root_child2.setFlexGrow(1);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -578,7 +596,7 @@ test('rounding_fractial_input_1', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(24);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -611,8 +629,8 @@ test('rounding_fractial_input_2', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -634,7 +652,7 @@ test('rounding_fractial_input_2', () => {
root_child2.setFlexGrow(1);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -656,7 +674,7 @@ test('rounding_fractial_input_2', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(25);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -689,12 +707,12 @@ test('rounding_fractial_input_3', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setPosition(Yoga.EDGE_TOP, 0.3);
root.setPosition(Edge.Top, 0.3);
root.setWidth(100);
root.setHeight(113.4);
@@ -713,7 +731,7 @@ test('rounding_fractial_input_3', () => {
root_child2.setFlexGrow(1);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -735,7 +753,7 @@ test('rounding_fractial_input_3', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(25);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -768,12 +786,12 @@ test('rounding_fractial_input_4', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setPosition(Yoga.EDGE_TOP, 0.7);
root.setPosition(Edge.Top, 0.7);
root.setWidth(100);
root.setHeight(113.4);
@@ -792,7 +810,7 @@ test('rounding_fractial_input_4', () => {
root_child2.setFlexGrow(1);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(1);
@@ -814,7 +832,7 @@ test('rounding_fractial_input_4', () => {
expect(root_child2.getComputedWidth()).toBe(100);
expect(root_child2.getComputedHeight()).toBe(24);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(1);
@@ -847,12 +865,12 @@ test('rounding_inner_node_controversy_horizontal', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(320);
const root_child0 = Yoga.Node.create(config);
@@ -874,7 +892,7 @@ test('rounding_inner_node_controversy_horizontal', () => {
root_child2.setFlexGrow(1);
root_child2.setHeight(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -901,7 +919,7 @@ test('rounding_inner_node_controversy_horizontal', () => {
expect(root_child2.getComputedWidth()).toBe(107);
expect(root_child2.getComputedHeight()).toBe(10);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -939,8 +957,8 @@ test('rounding_inner_node_controversy_vertical', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -965,7 +983,7 @@ test('rounding_inner_node_controversy_vertical', () => {
root_child2.setFlexGrow(1);
root_child2.setWidth(10);
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -992,7 +1010,7 @@ test('rounding_inner_node_controversy_vertical', () => {
expect(root_child2.getComputedWidth()).toBe(10);
expect(root_child2.getComputedHeight()).toBe(107);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1030,12 +1048,12 @@ test('rounding_inner_node_controversy_combined', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
root.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
root.setFlexDirection(FlexDirection.Row);
root.setWidth(640);
root.setHeight(320);
@@ -1073,7 +1091,7 @@ test('rounding_inner_node_controversy_combined', () => {
root_child2.setFlexGrow(1);
root_child2.setHeight("100%");
root.insertChild(root_child2, 2);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -1115,7 +1133,7 @@ test('rounding_inner_node_controversy_combined', () => {
expect(root_child2.getComputedWidth()).toBe(213);
expect(root_child2.getComputedHeight()).toBe(320);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);

42
javascript/tests/generated/YGSizeOverflowTest.test.js → javascript/tests/generated/YGSizeOverflowTest.test.ts
View File

@@ -7,12 +7,30 @@
// @generated by gentest/gentest.rb from gentest/fixtures/YGSizeOverflowTest.html
import {Yoga} from "../tools/globals";
import {
Align,
Direction,
Display,
Edge,
Errata,
ExperimentalFeature,
FlexDirection,
Gutter,
Justify,
MeasureMode,
Overflow,
PositionType,
Unit,
Wrap,
} from 'yoga-layout';
test('nested_overflowing_child', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -26,7 +44,7 @@ test('nested_overflowing_child', () => {
root_child0_child0.setWidth(200);
root_child0_child0.setHeight(200);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -43,7 +61,7 @@ test('nested_overflowing_child', () => {
expect(root_child0_child0.getComputedWidth()).toBe(200);
expect(root_child0_child0.getComputedHeight()).toBe(200);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -71,8 +89,8 @@ test('nested_overflowing_child_in_constraint_parent', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -88,7 +106,7 @@ test('nested_overflowing_child_in_constraint_parent', () => {
root_child0_child0.setWidth(200);
root_child0_child0.setHeight(200);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -105,7 +123,7 @@ test('nested_overflowing_child_in_constraint_parent', () => {
expect(root_child0_child0.getComputedWidth()).toBe(200);
expect(root_child0_child0.getComputedHeight()).toBe(200);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -133,8 +151,8 @@ test('parent_wrap_child_size_overflowing_parent', () => {
const config = Yoga.Config.create();
let root;
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_ABSOLUTE_PERCENTAGE_AGAINST_PADDING_EDGE, true);
config.setExperimentalFeatureEnabled(Yoga.EXPERIMENTAL_FEATURE_FIX_ABSOLUTE_TRAILING_COLUMN_MARGIN, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.AbsolutePercentageAgainstPaddingEdge, true);
config.setExperimentalFeatureEnabled(ExperimentalFeature.FixAbsoluteTrailingColumnMargin, true);
try {
root = Yoga.Node.create(config);
@@ -149,7 +167,7 @@ test('parent_wrap_child_size_overflowing_parent', () => {
root_child0_child0.setWidth(100);
root_child0_child0.setHeight(200);
root_child0.insertChild(root_child0_child0, 0);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
root.calculateLayout(undefined, undefined, Direction.LTR);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);
@@ -166,7 +184,7 @@ test('parent_wrap_child_size_overflowing_parent', () => {
expect(root_child0_child0.getComputedWidth()).toBe(100);
expect(root_child0_child0.getComputedHeight()).toBe(200);
root.calculateLayout(undefined, undefined, Yoga.DIRECTION_RTL);
root.calculateLayout(undefined, undefined, Direction.RTL);
expect(root.getComputedLeft()).toBe(0);
expect(root.getComputedTop()).toBe(0);