Rename java API

Summary: Rename java api to new use yoga naming

Reviewed By: IanChilds

Differential Revision: D4265345

fbshipit-source-id: 69ecfd8fac214f86b8b70647b9b909acd83d78b5

.buckconfig

@@ -0,0 +1,2 @@
+[cxx]
+  gtest_dep = //lib/gtest:gtest

.eslintrc

@@ -1,24 +0,0 @@
-{
-    "browser": true,
-    "shadow": true,
-    "globals": {
-        "jasmine": true,
-        "describe": true,
-        "beforeEach": true,
-        "afterEach": true,
-        "spyOn": true,
-        "it": true,
-        "xit": true,
-        "expect": true,
-        "require": true,
-        "global": true,
-        "__dirname": true,
-        "module": true,
-        "console": true,
-        "setTimeout": true,
-        "define": true
-    },
-    "rules": {
-        "quotes": [2, "single"]
-    }
-}

.gitignore

@@ -1,7 +1,10 @@
-a.out
-*.class
-/**/java/out/*
-/**/.idea/workspace.xml
-/lib/
-/node_modules/
-npm-debug.log
+.DS_STORE
+
+/buck-cache/
+/buck-out/
+/.buckconfig.local
+/.buckd
+/gentest/test.html
+
+# Visual studio code
+.vscode

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/gtest/googletest"]
+	path = lib/gtest/googletest
+	url = https://github.com/google/googletest.git

.hgignore

@@ -0,0 +1,10 @@
+.DS_STORE
+
+/buck-cache/
+/buck-out/
+/.buckconfig.local
+/.buckd
+/gentest/test.html
+
+# Visual studio code
+.vscode

.travis.yml

@@ -1,22 +1,30 @@
-language: node_js
-node_js:
-  - "0.12"
+# Copyright (c) 2014-present, Facebook, Inc.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree. An additional grant
+# of patent rights can be found in the PATENTS file in the same directory.
 
-sudo: false
+os: osx
+osx_image: xcode7.3
+language: cpp
+compiler: clang
 
 before_install:
-  - npm install grunt-cli -g
+  - brew update
+  - brew tap facebook/fb
+  - brew install buck
+  - brew cask install java
+  - brew outdated xctool || brew upgrade xctool
+  - brew install mono
+  - export JAVA_HOME=$(/usr/libexec/java_home -v 1.8)
+  - export PATH=$JAVA_HOME/bin:$PATH
 
-addons:
-  apt:
-    packages:
-      - gcc
-
-deploy:
-  provider: npm
-  email: ceberhardt@scottlogic.com
-  api_key:
-    secure: "Dk69FV717n91CRMv0UqzqZG6mrd4dSwd2PJDf1Fe0GOVPrVG9pmSTUmsk7JGli7EB57ovPGRhE/lcDGnlE+hEVw5DjZhGUUmZIFGg+FdcVomoiTRUYjRLwRUKEVxYw1TGCjJHm4rEx4qdkghahjf1YRYnivOn7ADhdH5THr7uQE="
-  on:
-    tags: true
-    branch: master
+script:
+  - buck test //:CSSLayout
+  - buck test //java:java
+  - buck test //YogaKit:YogaKit --config cxx.default_platform=iphonesimulator-x86_64 --config cxx.cflags=-DTRAVIS_CI
+  - sh csharp/tests/Facebook.Yoga/test_macos.sh
+  - buck run //benchmark:benchmark
+  - git checkout HEAD^
+  - buck run //benchmark:benchmark

BUCK

@@ -0,0 +1,49 @@
+# Copyright (c) 2014-present, Facebook, Inc.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree. An additional grant
+# of patent rights can be found in the PATENTS file in the same directory.
+
+include_defs('//YOGA_DEFS')
+
+BASE_COMPILER_FLAGS = [
+  '-fno-omit-frame-pointer',
+  '-fexceptions',
+  '-Wall',
+  '-Werror',
+  '-O3',
+]
+
+GMOCK_OVERRIDE_FLAGS = [
+  # gmock does not mark mocked methods as override, ignore the warnings in tests
+  '-Wno-inconsistent-missing-override',
+]
+
+COMPILER_FLAGS = BASE_COMPILER_FLAGS + ['-std=c11', '-fPIC']
+TEST_COMPILER_FLAGS = BASE_COMPILER_FLAGS + GMOCK_OVERRIDE_FLAGS + ['-std=c++11']
+
+cxx_library(
+  name = 'CSSLayout',
+  srcs = glob(['CSSLayout/*.c']),
+  tests=[':tests'],
+  exported_headers = subdir_glob([('', 'CSSLayout/*.h')]),
+  header_namespace = '',
+  compiler_flags = COMPILER_FLAGS,
+  deps = [] if THIS_IS_FBOBJC else [
+    csslayout_dep('lib/fb:ndklog'),
+  ],
+  visibility = ['PUBLIC'],
+)
+
+cxx_test(
+  name = 'tests',
+  contacts = ['emilsj@fb.com'],
+  srcs = glob(['tests/*.cpp']),
+  compiler_flags = TEST_COMPILER_FLAGS,
+  deps = [
+    ':CSSLayout',
+    GTEST_TARGET,
+  ],
+  visibility = ['PUBLIC'],
+)

CONTRIBUTING

@@ -29,9 +29,7 @@ disclosure of security bugs. In those cases, please go through the process
 outlined on that page and do not file a public issue.
 
 ## Coding Style
-* 2 spaces for indentation rather than tabs
-* 80 character line length
-* ...
+* format.sh
 
 ## License
 By contributing to css-layout, you agree that your contributions will be licensed

CSSLayout/YGEnums.h

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+typedef enum YGFlexDirection {
+  YGFlexDirectionColumn,
+  YGFlexDirectionColumnReverse,
+  YGFlexDirectionRow,
+  YGFlexDirectionRowReverse,
+  YGFlexDirectionCount,
+} YGFlexDirection;
+
+typedef enum YGMeasureMode {
+  YGMeasureModeUndefined,
+  YGMeasureModeExactly,
+  YGMeasureModeAtMost,
+  YGMeasureModeCount,
+} YGMeasureMode;
+
+typedef enum YGPrintOptions {
+  YGPrintOptionsLayout = 1,
+  YGPrintOptionsStyle = 2,
+  YGPrintOptionsChildren = 4,
+  YGPrintOptionsCount,
+} YGPrintOptions;
+
+typedef enum YGEdge {
+  YGEdgeLeft,
+  YGEdgeTop,
+  YGEdgeRight,
+  YGEdgeBottom,
+  YGEdgeStart,
+  YGEdgeEnd,
+  YGEdgeHorizontal,
+  YGEdgeVertical,
+  YGEdgeAll,
+  YGEdgeCount,
+} YGEdge;
+
+typedef enum YGPositionType {
+  YGPositionTypeRelative,
+  YGPositionTypeAbsolute,
+  YGPositionTypeCount,
+} YGPositionType;
+
+typedef enum YGDimension {
+  YGDimensionWidth,
+  YGDimensionHeight,
+  YGDimensionCount,
+} YGDimension;
+
+typedef enum YGJustify {
+  YGJustifyFlexStart,
+  YGJustifyCenter,
+  YGJustifyFlexEnd,
+  YGJustifySpaceBetween,
+  YGJustifySpaceAround,
+  YGJustifyCount,
+} YGJustify;
+
+typedef enum YGDirection {
+  YGDirectionInherit,
+  YGDirectionLTR,
+  YGDirectionRTL,
+  YGDirectionCount,
+} YGDirection;
+
+typedef enum YGLogLevel {
+  YGLogLevelError,
+  YGLogLevelWarn,
+  YGLogLevelInfo,
+  YGLogLevelDebug,
+  YGLogLevelVerbose,
+  YGLogLevelCount,
+} YGLogLevel;
+
+typedef enum YGWrap {
+  YGWrapNoWrap,
+  YGWrapWrap,
+  YGWrapCount,
+} YGWrap;
+
+typedef enum YGOverflow {
+  YGOverflowVisible,
+  YGOverflowHidden,
+  YGOverflowScroll,
+  YGOverflowCount,
+} YGOverflow;
+
+typedef enum YGExperimentalFeature {
+  YGExperimentalFeatureRounding,
+  YGExperimentalFeatureWebFlexBasis,
+  YGExperimentalFeatureCount,
+} YGExperimentalFeature;
+
+typedef enum YGAlign {
+  YGAlignAuto,
+  YGAlignFlexStart,
+  YGAlignCenter,
+  YGAlignFlexEnd,
+  YGAlignStretch,
+  YGAlignCount,
+} YGAlign;

CSSLayout/YGMacros.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+#define YG_EXTERN_C_BEGIN extern "C" {
+#define YG_EXTERN_C_END }
+#else
+#define YG_EXTERN_C_BEGIN
+#define YG_EXTERN_C_END
+#endif
+
+#ifdef _WINDLL
+#define WIN_EXPORT __declspec(dllexport)
+#else
+#define WIN_EXPORT
+#endif
+
+#ifndef FB_ASSERTIONS_ENABLED
+#define FB_ASSERTIONS_ENABLED 1
+#endif
+
+#if FB_ASSERTIONS_ENABLED
+#define YG_ABORT() abort()
+#else
+#define YG_ABORT()
+#endif
+
+#ifndef YG_ASSERT
+#define YG_ASSERT(X, message)              \
+  if (!(X)) {                              \
+    YGLog(YGLogLevelError, "%s", message); \
+    YG_ABORT();                            \
+  }
+#endif

CSSLayout/YGNodeList.c

@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include "YGNodeList.h"
+
+extern YGMalloc gYGMalloc;
+extern YGRealloc gYGRealloc;
+extern YGFree gYGFree;
+
+struct YGNodeList {
+  uint32_t capacity;
+  uint32_t count;
+  YGNodeRef *items;
+};
+
+YGNodeListRef YGNodeListNew(const uint32_t initialCapacity) {
+  const YGNodeListRef list = gYGMalloc(sizeof(struct YGNodeList));
+  YG_ASSERT(list != NULL, "Could not allocate memory for list");
+
+  list->capacity = initialCapacity;
+  list->count = 0;
+  list->items = gYGMalloc(sizeof(YGNodeRef) * list->capacity);
+  YG_ASSERT(list->items != NULL, "Could not allocate memory for items");
+
+  return list;
+}
+
+void YGNodeListFree(const YGNodeListRef list) {
+  if (list) {
+    gYGFree(list->items);
+    gYGFree(list);
+  }
+}
+
+uint32_t YGNodeListCount(const YGNodeListRef list) {
+  if (list) {
+    return list->count;
+  }
+  return 0;
+}
+
+void YGNodeListAdd(YGNodeListRef *listp, const YGNodeRef node) {
+  if (!*listp) {
+    *listp = YGNodeListNew(4);
+  }
+  YGNodeListInsert(listp, node, (*listp)->count);
+}
+
+void YGNodeListInsert(YGNodeListRef *listp, const YGNodeRef node, const uint32_t index) {
+  if (!*listp) {
+    *listp = YGNodeListNew(4);
+  }
+  YGNodeListRef list = *listp;
+
+  if (list->count == list->capacity) {
+    list->capacity *= 2;
+    list->items = gYGRealloc(list->items, sizeof(YGNodeRef) * list->capacity);
+    YG_ASSERT(list->items != NULL, "Could not extend allocation for items");
+  }
+
+  for (uint32_t i = list->count; i > index; i--) {
+    list->items[i] = list->items[i - 1];
+  }
+
+  list->count++;
+  list->items[index] = node;
+}
+
+YGNodeRef YGNodeListRemove(const YGNodeListRef list, const uint32_t index) {
+  const YGNodeRef removed = list->items[index];
+  list->items[index] = NULL;
+
+  for (uint32_t i = index; i < list->count - 1; i++) {
+    list->items[i] = list->items[i + 1];
+    list->items[i + 1] = NULL;
+  }
+
+  list->count--;
+  return removed;
+}
+
+YGNodeRef YGNodeListDelete(const YGNodeListRef list, const YGNodeRef node) {
+  for (uint32_t i = 0; i < list->count; i++) {
+    if (list->items[i] == node) {
+      return YGNodeListRemove(list, i);
+    }
+  }
+
+  return NULL;
+}
+
+YGNodeRef YGNodeListGet(const YGNodeListRef list, const uint32_t index) {
+  if (YGNodeListCount(list) > 0) {
+    return list->items[index];
+  }
+
+  return NULL;
+}

CSSLayout/YGNodeList.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "YGMacros.h"
+#include "Yoga.h"
+
+YG_EXTERN_C_BEGIN
+
+typedef struct YGNodeList *YGNodeListRef;
+
+YGNodeListRef YGNodeListNew(const uint32_t initialCapacity);
+void YGNodeListFree(const YGNodeListRef list);
+uint32_t YGNodeListCount(const YGNodeListRef list);
+void YGNodeListAdd(YGNodeListRef *listp, const YGNodeRef node);
+void YGNodeListInsert(YGNodeListRef *listp, const YGNodeRef node, const uint32_t index);
+YGNodeRef YGNodeListRemove(const YGNodeListRef list, const uint32_t index);
+YGNodeRef YGNodeListDelete(const YGNodeListRef list, const YGNodeRef node);
+YGNodeRef YGNodeListGet(const YGNodeListRef list, const uint32_t index);
+
+YG_EXTERN_C_END

CSSLayout/Yoga.h

@@ -0,0 +1,181 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <assert.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+// Not defined in MSVC++
+#ifndef NAN
+static const unsigned long __nan[2] = {0xffffffff, 0x7fffffff};
+#define NAN (*(const float *) __nan)
+#endif
+
+#define YGUndefined NAN
+
+#include "YGEnums.h"
+#include "YGMacros.h"
+
+YG_EXTERN_C_BEGIN
+
+typedef struct YGSize {
+  float width;
+  float height;
+} YGSize;
+
+typedef struct YGNode *YGNodeRef;
+typedef YGSize (*YGMeasureFunc)(YGNodeRef node,
+                                float width,
+                                YGMeasureMode widthMode,
+                                float height,
+                                YGMeasureMode heightMode);
+typedef void (*YGPrintFunc)(YGNodeRef node);
+typedef int (*YGLogger)(YGLogLevel level, const char *format, va_list args);
+
+typedef void *(*YGMalloc)(size_t size);
+typedef void *(*YGCalloc)(size_t count, size_t size);
+typedef void *(*YGRealloc)(void *ptr, size_t size);
+typedef void (*YGFree)(void *ptr);
+
+// YGNode
+WIN_EXPORT YGNodeRef YGNodeNew(void);
+WIN_EXPORT void YGNodeInit(const YGNodeRef node);
+WIN_EXPORT void YGNodeFree(const YGNodeRef node);
+WIN_EXPORT void YGNodeFreeRecursive(const YGNodeRef node);
+WIN_EXPORT void YGNodeReset(const YGNodeRef node);
+WIN_EXPORT int32_t YGNodeGetInstanceCount(void);
+
+WIN_EXPORT void YGNodeInsertChild(const YGNodeRef node,
+                                  const YGNodeRef child,
+                                  const uint32_t index);
+WIN_EXPORT void YGNodeRemoveChild(const YGNodeRef node, const YGNodeRef child);
+WIN_EXPORT YGNodeRef YGNodeGetChild(const YGNodeRef node, const uint32_t index);
+WIN_EXPORT uint32_t YGNodeChildCount(const YGNodeRef node);
+
+WIN_EXPORT void YGNodeCalculateLayout(const YGNodeRef node,
+                                      const float availableWidth,
+                                      const float availableHeight,
+                                      const YGDirection parentDirection);
+
+// Mark a node as dirty. Only valid for nodes with a custom measure function
+// set.
+// YG knows when to mark all other nodes as dirty but because nodes with
+// measure functions
+// depends on information not known to YG they must perform this dirty
+// marking manually.
+WIN_EXPORT void YGNodeMarkDirty(const YGNodeRef node);
+WIN_EXPORT bool YGNodeIsDirty(const YGNodeRef node);
+
+WIN_EXPORT void YGNodePrint(const YGNodeRef node, const YGPrintOptions options);
+
+WIN_EXPORT bool YGValueIsUndefined(const float value);
+
+WIN_EXPORT bool YGNodeCanUseCachedMeasurement(const YGMeasureMode widthMode,
+                                              const float width,
+                                              const YGMeasureMode heightMode,
+                                              const float height,
+                                              const YGMeasureMode lastWidthMode,
+                                              const float lastWidth,
+                                              const YGMeasureMode lastHeightMode,
+                                              const float lastHeight,
+                                              const float lastComputedWidth,
+                                              const float lastComputedHeight,
+                                              const float marginRow,
+                                              const float marginColumn);
+
+WIN_EXPORT void YGNodeCopyStyle(const YGNodeRef dstNode, const YGNodeRef srcNode);
+
+#define YG_NODE_PROPERTY(type, name, paramName)                          \
+  WIN_EXPORT void YGNodeSet##name(const YGNodeRef node, type paramName); \
+  WIN_EXPORT type YGNodeGet##name(const YGNodeRef node);
+
+#define YG_NODE_STYLE_PROPERTY(type, name, paramName)                               \
+  WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node, const type paramName); \
+  WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node);
+
+#define YG_NODE_STYLE_EDGE_PROPERTY(type, name, paramName)    \
+  WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node,  \
+                                       const YGEdge edge,     \
+                                       const type paramName); \
+  WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node, const YGEdge edge);
+
+#define YG_NODE_LAYOUT_PROPERTY(type, name) \
+  WIN_EXPORT type YGNodeLayoutGet##name(const YGNodeRef node);
+
+YG_NODE_PROPERTY(void *, Context, context);
+YG_NODE_PROPERTY(YGMeasureFunc, MeasureFunc, measureFunc);
+YG_NODE_PROPERTY(YGPrintFunc, PrintFunc, printFunc);
+YG_NODE_PROPERTY(bool, HasNewLayout, hasNewLayout);
+
+YG_NODE_STYLE_PROPERTY(YGDirection, Direction, direction);
+YG_NODE_STYLE_PROPERTY(YGFlexDirection, FlexDirection, flexDirection);
+YG_NODE_STYLE_PROPERTY(YGJustify, JustifyContent, justifyContent);
+YG_NODE_STYLE_PROPERTY(YGAlign, AlignContent, alignContent);
+YG_NODE_STYLE_PROPERTY(YGAlign, AlignItems, alignItems);
+YG_NODE_STYLE_PROPERTY(YGAlign, AlignSelf, alignSelf);
+YG_NODE_STYLE_PROPERTY(YGPositionType, PositionType, positionType);
+YG_NODE_STYLE_PROPERTY(YGWrap, FlexWrap, flexWrap);
+YG_NODE_STYLE_PROPERTY(YGOverflow, Overflow, overflow);
+
+WIN_EXPORT void YGNodeStyleSetFlex(const YGNodeRef node, const float flex);
+YG_NODE_STYLE_PROPERTY(float, FlexGrow, flexGrow);
+YG_NODE_STYLE_PROPERTY(float, FlexShrink, flexShrink);
+YG_NODE_STYLE_PROPERTY(float, FlexBasis, flexBasis);
+
+YG_NODE_STYLE_EDGE_PROPERTY(float, Position, position);
+YG_NODE_STYLE_EDGE_PROPERTY(float, Margin, margin);
+YG_NODE_STYLE_EDGE_PROPERTY(float, Padding, padding);
+YG_NODE_STYLE_EDGE_PROPERTY(float, Border, border);
+
+YG_NODE_STYLE_PROPERTY(float, Width, width);
+YG_NODE_STYLE_PROPERTY(float, Height, height);
+YG_NODE_STYLE_PROPERTY(float, MinWidth, minWidth);
+YG_NODE_STYLE_PROPERTY(float, MinHeight, minHeight);
+YG_NODE_STYLE_PROPERTY(float, MaxWidth, maxWidth);
+YG_NODE_STYLE_PROPERTY(float, MaxHeight, maxHeight);
+
+// Yoga specific properties, not compatible with flexbox specification
+// Aspect ratio control the size of the undefined dimension of a node.
+// - On a node with a set width/height aspect ratio control the size of the unset dimension
+// - On a node with a set flex basis aspect ratio controls the size of the node in the cross axis if
+// unset
+// - On a node with a measure function aspect ratio works as though the measure function measures
+// the flex basis
+// - On a node with flex grow/shrink aspect ratio controls the size of the node in the cross axis if
+// unset
+// - Aspect ratio takes min/max dimensions into account
+YG_NODE_STYLE_PROPERTY(float, AspectRatio, aspectRatio);
+
+YG_NODE_LAYOUT_PROPERTY(float, Left);
+YG_NODE_LAYOUT_PROPERTY(float, Top);
+YG_NODE_LAYOUT_PROPERTY(float, Right);
+YG_NODE_LAYOUT_PROPERTY(float, Bottom);
+YG_NODE_LAYOUT_PROPERTY(float, Width);
+YG_NODE_LAYOUT_PROPERTY(float, Height);
+YG_NODE_LAYOUT_PROPERTY(YGDirection, Direction);
+
+WIN_EXPORT void YGSetLogger(YGLogger logger);
+WIN_EXPORT void YGLog(YGLogLevel level, const char *message, ...);
+
+WIN_EXPORT void YGSetExperimentalFeatureEnabled(YGExperimentalFeature feature, bool enabled);
+WIN_EXPORT bool YGIsExperimentalFeatureEnabled(YGExperimentalFeature feature);
+
+WIN_EXPORT void
+YGSetMemoryFuncs(YGMalloc cssMalloc, YGCalloc cssCalloc, YGRealloc cssRealloc, YGFree cssFree);
+
+YG_EXTERN_C_END

Gruntfile.js

@@ -1,184 +0,0 @@
-'use strict';
-
-module.exports = function(grunt) {
-  var fs = require('fs');
-  var path = require('path');
-  var isWindows = /^win/.test(process.platform);
-
-  require('load-grunt-tasks')(grunt);
-
-  // config
-  var config = {
-    delimiter: path.delimiter,
-    libName: 'css-layout',
-    distFolder: 'dist',
-    srcFolder: 'src',
-    testFolder: 'src/__tests__',
-    javaLibFolder: 'src/java/lib',
-    javaSource: 'src/java/tests/com/facebook/csslayout/*.java',
-    javaTestFiles: 'org.junit.runner.JUnitCore com.facebook.csslayout.LayoutEngineTest com.facebook.csslayout.LayoutCachingTest com.facebook.csslayout.CSSNodeTest'
-  };
-
-  // C compilation configuration
-  if (isWindows) {
-    // Windows build, assumes cl is in the path (see https://msdn.microsoft.com/en-us/library/f2ccy3wt.aspx).
-    config.cTestOutput = 'c_test.exe';
-    config.cTestCompile = 'cl -nologo -Zi -Tpsrc/__tests__/Layout-test.c -Tpsrc/Layout.c -Tpsrc/Layout-test-utils.c -link -incremental:no -out:"<%= config.cTestOutput %>"';
-    config.cTestExecute = '<%= config.cTestOutput %>';
-    config.cTestClean = ['<%= config.cTestOutput %>','*.obj','*.pdb'];
-  }
-  else {
-    // GCC build (OSX, Linux, ...), assumes gcc is in the path.
-    config.cTestOutput = 'c_test';
-    config.cTestCompile = 'gcc -std=c99 -Werror -Wno-padded src/__tests__/Layout-test.c src/Layout.c src/Layout-test-utils.c -lm -o "./<%= config.cTestOutput %>"';
-    config.cTestExecute = './<%= config.cTestOutput %>';
-    config.cTestClean = ['<%= config.cTestOutput %>'];
-  }
-
-  grunt.initConfig({
-    config: config,
-
-    mkdir: {
-      dist: {
-        options: {
-          create: ['<%= config.distFolder %>']
-        },
-      },
-    },
-
-    clean: {
-      dist: ['<%= config.distFolder %>'],
-      cTest: config.cTestClean,
-      javaTest: ['**/*.class']
-    },
-
-    eslint: {
-      options: {
-        configFile: '.eslintrc'
-      },
-      target: ['<%= config.srcFolder %>/Layout.js']
-    },
-
-    includereplace: {
-      options: {
-        prefix: '// @@',
-      },
-      main: {
-        src: '<%= config.srcFolder %>/<%= config.libName %>.js',
-        dest: '<%= config.distFolder %>/<%= config.libName %>.js'
-      }
-    },
-
-    uglify: {
-      options: {
-        sourceMap: true,
-        sourceMapIncludeSources: true
-      },
-      main: {
-        files: {
-          '<%= config.distFolder %>/<%= config.libName %>.min.js':
-            ['<%= config.distFolder %>/<%= config.libName %>.js']
-        }
-      }
-    },
-
-    karma: {
-      main: {
-        options: {
-          files: [
-            '<%= config.srcFolder %>/Layout.js',
-            '<%= config.srcFolder %>/Layout-test-utils.js',
-            '<%= config.testFolder %>/Layout-test.js',
-            '<%= config.testFolder %>/Layout-consts-test.js'
-          ],
-          browsers: ['Chrome'],
-          frameworks: ['jasmine'],
-          singleRun: true
-        }
-      }
-    },
-
-    execute: {
-      transpile: {
-        src: ['<%= config.srcFolder %>/transpile.js']
-      }
-    },
-
-    concat: {
-      options: {
-        separator: '\n',
-        // Replace all 'use strict' statements in the code with a single one at the top
-        banner: [
-          '/*',
-          ' * #define CSS_LAYOUT_IMPLEMENTATION',
-          ' * before you include this file in *one* C or C++ file to create the implementation.',
-          ' */\n'
-        ].join('\n'),
-        process: function(src, filepath) {
-          if (path.extname(filepath) === '.c') {
-            return [
-              '#ifdef CSS_LAYOUT_IMPLEMENTATION',
-              src,
-              '#endif // CSS_LAYOUT_IMPLEMENTATION'
-            ].join('\n')
-          }
-          else {
-            return src;
-          }
-        },
-      },
-      dist: {
-        src: ['<%= config.srcFolder %>/Layout.h', '<%= config.srcFolder %>/Layout.c'],
-        dest: '<%= config.distFolder %>/css-layout.h',
-      },
-    },
-
-    shell: {
-      cCompile: {
-        command: config.cTestCompile
-      },
-      cTestExecute: {
-        command: config.cTestExecute
-      },
-      javaCompile: {
-        command: 'javac -cp <%= config.javaLibFolder %>/junit4.jar<%= config.delimiter %><%= config.javaLibFolder %>/jsr305.jar<%= config.delimiter %><%= config.javaLibFolder %>/infer-annotations-1.4.jar' + ' -sourcepath ./src/java/src<%= config.delimiter %>./src/java/tests' + ' <%= config.javaSource %>'
-      },
-      javaTestExecute: {
-        command: 'java -cp ./src/java/src<%= config.delimiter %>./src/java/tests<%= config.delimiter %><%= config.javaLibFolder %>/junit4.jar<%= config.delimiter %><%= config.javaLibFolder %>/infer-annotations-1.4.jar <%= config.javaTestFiles %>'
-      },
-      javaPackage: {
-        command: 'jar cf <%= config.distFolder %>/<%= config.libName %>.jar <%= config.javaSource %>'
-      }
-    }
-  });
-
-  // Compiles and runs the Java tests
-  grunt.registerTask('test-java', ['shell:javaCompile', 'shell:javaTestExecute', 'clean:javaTest']);
-
-  // Compiles and runs the C tests
-  grunt.registerTask('test-c', ['shell:cCompile', 'shell:cTestExecute', 'clean:cTest']);
-
-  // Transpiles the JavaScript to C and Java, running tests
-  grunt.registerTask('transpile', ['execute:transpile', 'test-c', 'test-java']);
-
-  // Lints and tests the JavaScritp using Chrome
-  grunt.registerTask('test-javascript', ['eslint', 'karma']);
-
-  // Packages the JavaScript as a single UMD module and minifies
-  grunt.registerTask('package-javascript', ['mkdir:dist', 'includereplace', 'uglify']);
-
-  // Packages the Java as a JAR
-  grunt.registerTask('package-java', ['mkdir:dist', 'shell:javaPackage']);
-
-  // Packages the C code as a single header
-  grunt.registerTask('package-c', ['mkdir:dist', 'concat']);
-
-  // Default build, performs the full works!
-  grunt.registerTask('build', ['test-javascript', 'transpile', 'clean:dist', 'package-javascript', 'package-java', 'package-c']);
-
-  // The JavaScript unit tests require Chrome (they need a faithful flexbox implementation
-  // to test against), so under CI this step is skipped.
-  grunt.registerTask('ci', ['eslint', 'transpile', 'clean:dist', 'package-javascript', 'package-java', 'package-c']);
-
-  grunt.registerTask('default', ['build']);
-};

LICENSE

@@ -2,7 +2,7 @@ BSD License
 
 For css-layout software
 
-Copyright (c) 2014, Facebook, Inc. All rights reserved.
+Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:

README.md

@@ -1,106 +1,19 @@
-css-layout [![Build Status](https://travis-ci.org/facebook/css-layout.svg?branch=master)](https://travis-ci.org/facebook/css-layout)
-==========
+# CSSLayout [![Build Status](https://travis-ci.org/facebook/css-layout.svg?branch=master)](https://travis-ci.org/facebook/css-layout)
 
-This project implements a subset of CSS including flexbox and the box model using pure JavaScript, then transpiled to C and Java. The goal is to have a small standalone library to layout elements. It doesn't rely on the DOM at all.
+## NOTICE
+A lot is changing this week in the API regarding naming. We suggest you hold off updating to the latest version of the code until this notice is gone. Expect it to take about a week.
 
-In order to make sure that the code is correct, it is developed in JavaScript using TDD where each commit adds a unit test and the associated code to make it work. All the unit tests are tested against Chrome's implementation of CSS.
+## Goals
+CSSLayout is a cross-platform implementation of flexbox. The goal of CSSLayout is allow native developers to have the same expressive layout system as developers developing for the modern web are used to. CSSLayout allows developers for web, android, iOS, and windows to use the same layout primitives across platforms. This saves time, increases collaboration between platform teams, and makes it easier for developers to work on multiple platforms.
 
-The JavaScript version has been implemented in a way that can be easily transpiled to C and Java via regexes. The layout function doesn't do any allocation nor uses any of the dynamic aspect of JavaScript. The tests are also transpiled to make sure that the implementations are correct everywhere.
+The goal of CSSLayout is not to re-implement all of css. CSSLayout only targets flexbox, and does not have any plans on implementing support for tables, floats, or any other css concepts. CSSLayout also does not plan on supporting styling properties which do not affect layout such as color or background properties.
 
 
-Usage
------
+## Differences from web
+CSSLayout tries to stay as close as possible to the web implementation of flexbox. There are however certain cases where CSSLayout differs from the web implementation.
 
-A single function `computeLayout` is exposed that
- - takes a tree of nodes: `{ style: { ... }, children: [ nodes ] }`
- - computes the layout and writes it back to the node tree.
-
-For example,
-
-```javascript
-// create an initial tree of nodes
-var nodeTree = {
-    "style": {
-      "padding": 50
-    },
-    "children": [
-      {
-        "style": {
-          "padding": 10,
-          "alignSelf": "stretch"
-        }
-      }
-    ]
-  };
-
-// compute the layout
-computeLayout(nodeTree);
-
-// the layout information is written back to the node tree, with
-// each node now having a layout property: 
-
-// JSON.stringify(nodeTree, null, 2);
-{
-  "style": {
-    "padding": 50
-  },
-  "children": [
-    {
-      "style": {
-        "padding": 10,
-        "alignSelf": "stretch"
-      },
-      "layout": {
-        "width": 20,
-        "height": 20,
-        "top": 50,
-        "left": 50,
-        "right": 50,
-        "bottom": 50,
-        "direction": "ltr"
-      },
-      "children": [],
-      "lineIndex": 0
-    }
-  ],
-  "layout": {
-    "width": 120,
-    "height": 120,
-    "top": 0,
-    "left": 0,
-    "right": 0,
-    "bottom": 0,
-    "direction": "ltr"
-  }
-}
-```
-
-Supported Attributes
---------------------
-
-Name | Value
-----:|------
-width, height | positive number
-minWidth, minHeight | positive number
-maxWidth, maxHeight | positive number
-left, right, top, bottom | number
-margin, marginLeft, marginRight, marginTop, marginBottom | number
-padding, paddingLeft, paddingRight, paddingTop, paddingBottom | positive number
-borderWidth, borderLeftWidth, borderRightWidth, borderTopWidth, borderBottomWidth | positive number
-flexDirection | 'column', 'row'
-justifyContent | 'flex-start', 'center', 'flex-end', 'space-between', 'space-around'
-alignItems, alignSelf, alignContent | 'flex-start', 'center', 'flex-end', 'stretch'
-flex | positive number
-flexWrap | 'wrap', 'nowrap'
-position | 'relative', 'absolute'
-
-- `inherit` value is not implemented because it's a way to disambiguate between multiple colliding rules. This should be done in a pre-processing step, not in the actual layout algorithm.
-
-
-
-Default values
---------------
-Since we are only using flexbox, we can use defaults that are much more sensible. This is the configuration to use in order to get the same behavior using the DOM and CSS. You can try those default settings with the [following JSFiddle](http://jsfiddle.net/vjeux/y11txxv9/).
+### Default values
+CSSLayout has chosen to make changes to the default values of certain properties. These default values were chosen based on our usage of the library. When testing layout with tools such as JSFiddle you can apply the following css style to ensure the defaults match those of CSSLayout. Or fork the [following JSFiddle](http://jsfiddle.net/vjeux/y11txxv9/).
 
 ```css
 div, span {
@@ -116,6 +29,7 @@ div, span {
   border: 0 solid black;
   margin: 0;
   padding: 0;
+  min-width: 0;
 }
 ```
 
@@ -124,15 +38,125 @@ div, span {
 - All the flex elements are oriented from top to bottom, left to right and do not shrink. This is how things are laid out using the default CSS settings and what you'd expect.
 - Everything is `position: relative`. This makes `position: absolute` target the direct parent and not some parent which is either `relative` or `absolute`. If you want to position an element relative to something else, you should move it in the DOM instead of relying of CSS. It also makes `top, left, right, bottom` do something when not specifying `position: absolute`.
 
-Development
------------
+### Size units
+CSSLayout currently only supports pixel sizes. The reason being that we have not seen the need for any other units. We would like to support percentage units sometime in the future.
 
-The core logic resides with `Layout.js`, which is transpiled into equivalent C and Java implementations.
+### -start and -end properties
+We think supporting RTL locales is very important. Therefor CSSLayout supports non-standards -start and -end suffixed versions of margin, padding, border, and position.
 
-The JavaScript build process is managed via Grunt. The build performs linting, runs the tests against Chrome, transpiles and packages the code (JavaScript and Java) into the `dist` folder. For JavaScript, the build output uses the Universal Module Format (UMD) so that it can be used via AMD / RequireJS, CommonJS or included directly into an HTML page.
 
-While developing you can just run the lint / Chrome-based tests a follows:
+## Usage
 
+### C
+The full API can be found in `CSSLayout/CSSLayout.h`.
+
+```c
+CSSNodeRef root = CSSNodeNew();
+CSSNodeStyleSetWidth(root, 100);
+CSSNodeStyleSetHeight(root, 100);
+
+for (uint32_t i = 0; i < 10; i++) {
+  CSSNodeRef child = CSSNodeNew();
+  CSSNodeStyleSetHeight(child, 10);
+  CSSNodeInsertChild(root, child, 0);
+}
+
+CSSNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+// Get for resulting layout
+CSSNodeLayoutGetLeft(root);
+CSSNodeLayoutGetTop(root);
+CSSNodeLayoutGetWidth(root);
+CSSNodeLayoutGetHeight(root);
 ```
-grunt test-javascript
+
+### Java
+The full API can be found in `java/com/facebook/csslayout/CSSNode.java`.
+
+```java
+CSSNode root = new CSSNode();
+root.setStyleWidth(100);
+root.setStyleHeight(100);
+
+for (int i = 0; i < 10; i++) {
+  CSSNode child = new CSSNode();
+  child.setStyleHeight(10);
+  root.addChildAt(child, 0);
+}
+
+root.calculateLayout(new CSSLayoutContext());
+
+// Get for resulting layout
+root.getLayoutX();
+root.getLayoutY();
+root.getLayoutWidth();
+root.getLayoutHeight();
 ```
+
+### UIKit
+The full API can be found in `YogaKit/UIView+Yoga.h`.
+
+```objective-c
+UIView *root = [UIView new];
+[root yg_setUsesYoga:YES];
+[root yg_setWidth:100];
+[root yg_setHeight:100];
+
+for (NSUInteger i = 0; i < 10; i++) {
+  UIView *child = [UIView new];
+  [child yg_setUsesYoga:YES];
+  [child yg_setHeight:10];
+  [root addSubview:child];
+}
+
+// Resulting layout will be set on the UIView hierarchy frames.
+[root yg_applyLayout];
+```
+
+### .NET
+The full API can be found in `csharp/Facebook.CSSLayout/CSSNode.cs`.
+
+```csharp
+var root = new CSSNode();
+root.StyleWidth = 100;
+root.StyleHeight = 100;
+
+for (var i = 0; i < 10; i++)
+{
+  var child = new CSSNode();
+  child.StyleHeight = 10;
+  root.Insert(0, child);
+}
+
+// Get for resulting layout
+root.LayoutX;
+root.LayoutY;
+root.LayoutWidth;
+root.LayoutHeight;
+```
+
+## Contributing
+To contribute to CSSLayout you need to first install [buck](https://buckbuild.com) which is the build system used by CSSLayout. CSSLayout is implemented in C with language bindings for Java, Objective-C, and .NET. When making changes to `CSSLayout/CSSLayout.h` please ensure to update `java/jni/CSSJNI.h`, `java/com/facebook/csslayout/CSSNode.java`, `uikit/CSSLayout/UIView+CSSLayout.m`, and `csharp/Facebook.CSSLayout/CSSNode.cs` to reflect the API change. Before submitting any code please run `format.sh` to ensure the code matches the project's code style.
+
+Before making any larger changes to CSSLayout please open an issue with a RFC so the changes can be discussed first. Generally we are very open to changes and improvements that will benefit the community.
+
+### Testing
+For any changes you make you should ensure that all the tests are passing. In case you make any fixes or additions to the library please also add at least one test to ensure we don't break anything in the future. Tests are located in `tests/CSSLayoutTest.cpp`. Run the tests by executing `buck test //:CSSLayout`.
+
+Instead of manually writing a test which ensures parity with web implementations of flexbox you can run `gentest/gentest.rb` to generated a test for you. You can write html which you want to verify in CSSLayout, in `gentest/fixtures` folder, such as the following.
+
+```html
+<div style="width: 100px; height: 100px; align-items: center;">
+  <div style="width: 50px; height: 50px;"></div>
+</div>
+```
+
+Run `gentest/gentest.rb` to generate test code and re-run `buck test //:CSSLayout` to validate the behavior. One test case will be generated for every root `div` in the input html.
+
+You may need to install the latest watir-webdriver gem (`gem install watir-webdriver`) and [ChromeDriver](https://sites.google.com/a/chromium.org/chromedriver/) to run `gentest/gentest.rb` Ruby script.
+
+#### .NET
+.NET testing is not integrated in buck yet, you might need to set up .NET testing environment. We have a script which to launch C# test on macOS, `csharp/tests/Facebook.CSSLayout/test_macos.sh`.
+
+### Benchmarks
+Benchmarks are located in `benchmarks/CSSBenchmark.c` and can be run with `buck run //benchmarks:benchmarks`. If you think your change has affected performance please run this before and after your change to validate that nothing has regressed.

YOGA_DEFS

@@ -0,0 +1,27 @@
+
+CSSLAYOUT_ROOT = '//...'
+INFER_ANNOTATIONS_TARGET = '//lib/infer-annotations:infer-annotations'
+JSR_305_TARGET = '//lib/jsr-305:jsr-305'
+JUNIT_TARGET = '//lib/junit:junit'
+PROGRUARD_ANNOTATIONS_TARGET = '//java/com/facebook/proguard/annotations:annotations'
+SOLOADER_TARGET = '//lib/soloader:soloader'
+GTEST_TARGET = '//lib/gtest:gtest'
+JNI_TARGET = '//lib/jni:jni'
+FBJNI_TARGET = '//lib/fb:fbjni'
+
+THIS_IS_FBOBJC = False
+
+CXX_LIBRARY_WHITELIST = [
+  '//:CSSLayout',
+  '//lib/fb:fbjni',
+  '//java:jni',
+]
+
+def csslayout_dep(dep):
+  return '//' + dep
+
+class allow_unsafe_import:
+    def __enter__(self):
+        pass
+    def __exit__(self, type, value, traceback):
+        pass

YogaKit/BUCK

@@ -0,0 +1,59 @@
+# Copyright (c) 2014-present, Facebook, Inc.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree. An additional grant
+# of patent rights can be found in the PATENTS file in the same directory.
+
+include_defs('//YOGA_DEFS')
+
+UIKIT_CSSLAYOUT_COMPILER_FLAGS = [
+  '-fobjc-arc',
+  '-Wconditional-uninitialized',
+  '-Wdangling-else',
+  '-Wdeprecated-declarations',
+  '-Wimplicit-retain-self',
+  '-Wincomplete-implementation',
+  '-Wobjc-method-access',
+  '-Wobjc-missing-super-calls',
+  '-Wmismatched-return-types',
+  '-Wreturn-type',
+  '-Wno-global-constructors',
+  '-Wno-shadow',
+  '-Wunused-const-variable',
+  '-Wunused-function',
+  '-Wunused-property-ivar',
+  '-Wunused-result',
+  '-Wunused-value',
+]
+
+apple_library(
+  name = 'YogaKit',
+  compiler_flags = UIKIT_CSSLAYOUT_COMPILER_FLAGS,
+  tests = [':YogaKitTests'],
+  srcs = glob(['*.m']),
+  exported_headers = glob(['*.h']),
+  frameworks = [
+    '$SDKROOT/System/Library/Frameworks/Foundation.framework',
+    '$SDKROOT/System/Library/Frameworks/UIKit.framework',
+  ],
+  deps = [
+    csslayout_dep(':CSSLayout'),
+  ],
+  visibility = ['PUBLIC'],
+)
+
+apple_test(
+  name = 'YogaKitTests',
+  compiler_flags = UIKIT_CSSLAYOUT_COMPILER_FLAGS,
+  info_plist = 'Tests/Info.plist',
+  srcs = glob(['Tests/**/*.m']),
+  frameworks = [
+    '$SDKROOT/System/Library/Frameworks/CoreGraphics.framework',
+    '$PLATFORM_DIR/Developer/Library/Frameworks/XCTest.framework',
+  ],
+  deps = [
+    ':YogaKit',
+  ],
+  visibility = ['PUBLIC'],
+)

YogaKit/Tests/Info.plist

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.facebook.${PRODUCT_NAME:rfc1034identifier}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundlePackageType</key>
+	<string>BNDL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+</dict>
+</plist>

YogaKit/Tests/YogaKitTests.m

@@ -0,0 +1,271 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <XCTest/XCTest.h>
+
+#import "UIView+Yoga.h"
+
+@interface YogaKitTests : XCTestCase
+@end
+
+@implementation YogaKitTests
+
+#ifndef TRAVIS_CI
+
+- (void)testNodesAreDeallocedWithSingleView
+{
+  XCTAssertEqual(0, YGNodeGetInstanceCount());
+
+  UIView *view = [[UIView alloc] initWithFrame:CGRectZero];
+  [view yg_setFlexBasis:1];
+  XCTAssertEqual(1, YGNodeGetInstanceCount());
+  view = nil;
+
+  XCTAssertEqual(0, YGNodeGetInstanceCount());
+}
+
+- (void)testNodesAreDeallocedCascade
+{
+  XCTAssertEqual(0, YGNodeGetInstanceCount());
+
+  UIView *view = [[UIView alloc] initWithFrame:CGRectZero];
+  [view yg_setFlexBasis:1];
+
+  for (int i=0; i<10; i++) {
+    UIView *subview = [[UIView alloc] initWithFrame:CGRectZero];
+    [subview yg_setFlexBasis:1];
+    [view addSubview:subview];
+  }
+  XCTAssertEqual(11, YGNodeGetInstanceCount());
+  view = nil;
+
+  XCTAssertEqual(0, YGNodeGetInstanceCount());
+}
+
+#endif
+
+- (void)testUsesYoga
+{
+  UIView *view = [[UIView alloc] initWithFrame:CGRectZero];
+  XCTAssertFalse([view yg_usesYoga]);
+
+  [view yg_setUsesYoga:YES];
+  XCTAssertTrue([view yg_usesYoga]);
+
+  [view yg_setUsesYoga:NO];
+  XCTAssertFalse([view yg_usesYoga]);
+}
+
+- (void)testSizeThatFitsAsserts
+{
+  UIView *view = [[UIView alloc] initWithFrame:CGRectZero];
+  dispatch_sync(dispatch_queue_create("com.facebook.Yoga.testing", DISPATCH_QUEUE_SERIAL), ^(void){
+    XCTAssertThrows([view yg_intrinsicSize]);
+  });
+}
+
+- (void)testSizeThatFitsSmoke
+{
+  UIView *container = [[UIView alloc] initWithFrame:CGRectZero];
+  [container yg_setUsesYoga:YES];
+  [container yg_setFlexDirection:YGFlexDirectionRow];
+  [container yg_setAlignItems:YGAlignFlexStart];
+
+  UILabel *longTextLabel = [[UILabel alloc] initWithFrame:CGRectZero];
+  longTextLabel.text = @"This is a very very very very very very very very long piece of text.";
+  longTextLabel.lineBreakMode = NSLineBreakByTruncatingTail;
+  longTextLabel.numberOfLines = 1;
+  [longTextLabel yg_setUsesYoga:YES];
+  [longTextLabel yg_setFlexShrink:1];
+  [container addSubview:longTextLabel];
+
+  UIView *textBadgeView = [[UIView alloc] initWithFrame:CGRectZero];
+  [textBadgeView yg_setUsesYoga:YES];
+  [textBadgeView yg_setMargin:3.0 forEdge:YGEdgeLeft];
+  [textBadgeView yg_setWidth:10];
+  [textBadgeView yg_setHeight:10];
+  [container addSubview:textBadgeView];
+
+  const CGSize containerSize = [container yg_intrinsicSize];
+  XCTAssertTrue(CGSizeEqualToSize(CGSizeMake(514,21), containerSize), @"Size is actually %@", NSStringFromCGSize(containerSize));
+}
+
+- (void)testFrameAndOriginPlacement
+{
+  const CGSize containerSize = CGSizeMake(320, 50);
+
+  UIView *container = [[UIView alloc] initWithFrame:CGRectMake(0, 0, containerSize.width, containerSize.height)];
+  [container yg_setUsesYoga:YES];
+  [container yg_setFlexDirection:YGFlexDirectionRow];
+
+  for (int i = 0; i < 3; i++) {
+    UIView *subview = [[UIView alloc] initWithFrame:CGRectZero];
+    [subview yg_setUsesYoga:YES];
+    [subview yg_setFlexGrow:1];
+
+    [container addSubview:subview];
+  }
+  [container yg_applyLayout];
+
+  XCTAssertFalse(CGRectIntersectsRect([container.subviews objectAtIndex:0].frame, [container.subviews objectAtIndex:1].frame));
+  XCTAssertFalse(CGRectIntersectsRect([container.subviews objectAtIndex:1].frame, [container.subviews objectAtIndex:2].frame));
+  XCTAssertFalse(CGRectIntersectsRect([container.subviews objectAtIndex:0].frame, [container.subviews objectAtIndex:2].frame));
+
+  CGFloat totalWidth = 0;
+  for (UIView *view in container.subviews) {
+    totalWidth += view.bounds.size.width;
+  }
+
+  XCTAssertEqual(containerSize.width, totalWidth, @"The container's width is %.6f, the subviews take up %.6f", containerSize.width, totalWidth);
+}
+
+- (void)testThatLayoutIsCorrectWhenWeSwapViewOrder
+{
+  const CGSize containerSize = CGSizeMake(300, 50);
+
+  UIView *container = [[UIView alloc] initWithFrame:CGRectMake(0, 0, containerSize.width, containerSize.height)];
+  [container yg_setUsesYoga:YES];
+  [container yg_setFlexDirection:YGFlexDirectionRow];
+
+  UIView *subview1 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview1 yg_setUsesYoga:YES];
+  [subview1 yg_setFlexGrow:1];
+  [container addSubview:subview1];
+
+  UIView *subview2 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview2 yg_setUsesYoga:YES];
+  [subview2 yg_setFlexGrow:1];
+  [container addSubview:subview2];
+
+  UIView *subview3 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview3 yg_setUsesYoga:YES];
+  [subview3 yg_setFlexGrow:1];
+  [container addSubview:subview3];
+
+  [container yg_applyLayout];
+
+  XCTAssertTrue(CGRectEqualToRect(subview1.frame, CGRectMake(0, 0, 100, 50)));
+  XCTAssertTrue(CGRectEqualToRect(subview2.frame, CGRectMake(100, 0, 100, 50)), @"It's actually %@", NSStringFromCGRect(subview2.frame));
+  XCTAssertTrue(CGRectEqualToRect(subview3.frame, CGRectMake(200, 0, 100, 50)));
+
+  [container exchangeSubviewAtIndex:2 withSubviewAtIndex:0];
+  [subview2 yg_setIncludeInLayout:NO];
+  [container yg_applyLayout];
+
+  XCTAssertTrue(CGRectEqualToRect(subview3.frame, CGRectMake(0, 0, 150, 50)));
+  XCTAssertTrue(CGRectEqualToRect(subview1.frame, CGRectMake(150, 0, 150, 50)));
+
+  // this frame shouldn't have been modified since last time.
+  XCTAssertTrue(CGRectEqualToRect(subview2.frame, CGRectMake(100, 0, 100, 50)));
+}
+
+- (void)testThatWeRespectIncludeInLayoutFlag
+{
+  const CGSize containerSize = CGSizeMake(300, 50);
+
+  UIView *container = [[UIView alloc] initWithFrame:CGRectMake(0, 0, containerSize.width, containerSize.height)];
+  [container yg_setUsesYoga:YES];
+  [container yg_setFlexDirection:YGFlexDirectionRow];
+
+  UIView *subview1 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview1 yg_setUsesYoga:YES];
+  [subview1 yg_setFlexGrow:1];
+  [container addSubview:subview1];
+
+  UIView *subview2 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview2 yg_setUsesYoga:YES];
+  [subview2 yg_setFlexGrow:1];
+  [container addSubview:subview2];
+
+  UIView *subview3 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview3 yg_setUsesYoga:YES];
+  [subview3 yg_setFlexGrow:1];
+  [container addSubview:subview3];
+
+  [container yg_applyLayout];
+
+  for (UIView *view in container.subviews) {
+    XCTAssertTrue(CGSizeEqualToSize(CGSizeMake(100, 50), subview1.bounds.size), @"Actual size is %@", NSStringFromCGSize(view.bounds.size));
+  }
+
+  [subview3 yg_setIncludeInLayout:NO];
+  [container yg_applyLayout];
+
+  XCTAssertTrue(CGSizeEqualToSize(CGSizeMake(150, 50), subview1.bounds.size), @"Actual size is %@", NSStringFromCGSize(subview1.bounds.size));
+  XCTAssertTrue(CGSizeEqualToSize(CGSizeMake(150, 50), subview2.bounds.size), @"Actual size is %@", NSStringFromCGSize(subview2.bounds.size));
+
+  // We don't set the frame to zero, so, it should be set to what it was previously at.
+  XCTAssertTrue(CGSizeEqualToSize(CGSizeMake(100, 50), subview3.bounds.size), @"Actual size is %@", NSStringFromCGSize(subview3.bounds.size));
+}
+
+- (void)testThatNumberOfChildrenIsCorrectWhenWeIgnoreSubviews
+{
+  UIView *container = [[UIView alloc] initWithFrame:CGRectZero];
+  [container yg_setUsesYoga:YES];
+  [container yg_setFlexDirection:YGFlexDirectionRow];
+
+  UIView *subview1 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview1 yg_setUsesYoga:YES];
+  [subview1 yg_setIncludeInLayout:NO];
+  [container addSubview:subview1];
+
+  UIView *subview2 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview2 yg_setUsesYoga:YES];
+  [subview2 yg_setIncludeInLayout:NO];
+  [container addSubview:subview2];
+
+  UIView *subview3 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview3 yg_setUsesYoga:YES];
+  [subview3 yg_setIncludeInLayout:YES];
+  [container addSubview:subview3];
+
+  [container yg_applyLayout];
+  XCTAssertEqual(1, [container yg_numberOfChildren]);
+
+  [subview2 yg_setIncludeInLayout:YES];
+  [container yg_applyLayout];
+  XCTAssertEqual(2, [container yg_numberOfChildren]);
+}
+
+- (void)testThatViewNotIncludedInFirstLayoutPassAreIncludedInSecond
+{
+  UIView *container = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 300, 50)];
+  [container yg_setUsesYoga:YES];
+  [container yg_setFlexDirection:YGFlexDirectionRow];
+
+  UIView *subview1 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview1 yg_setUsesYoga:YES];
+  [subview1 yg_setFlexGrow:1];
+  [container addSubview:subview1];
+
+  UIView *subview2 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview2 yg_setUsesYoga:YES];
+  [subview2 yg_setFlexGrow:1];
+  [container addSubview:subview2];
+
+  UIView *subview3 = [[UIView alloc] initWithFrame:CGRectZero];
+  [subview3 yg_setUsesYoga:YES];
+  [subview3 yg_setFlexGrow:1];
+  [subview3 yg_setIncludeInLayout:NO];
+  [container addSubview:subview3];
+
+  [container yg_applyLayout];
+
+  XCTAssertTrue(CGSizeEqualToSize(CGSizeMake(150, 50), subview1.bounds.size), @"Actual size is %@", NSStringFromCGSize(subview1.bounds.size));
+  XCTAssertTrue(CGSizeEqualToSize(CGSizeMake(150, 50), subview2.bounds.size), @"Actual size is %@", NSStringFromCGSize(subview2.bounds.size));
+  XCTAssertTrue(CGSizeEqualToSize(CGSizeZero, subview3.bounds.size), @"Actual size %@", NSStringFromCGSize(subview3.bounds.size));
+
+  [subview3 yg_setIncludeInLayout:YES];
+  [container yg_applyLayout];
+  for (UIView *view in container.subviews) {
+    XCTAssertTrue(CGSizeEqualToSize(CGSizeMake(100, 50), subview1.bounds.size), @"Actual size is %@", NSStringFromCGSize(view.bounds.size));
+  }
+}
+
+@end

YogaKit/UIView+Yoga.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <UIKit/UIKit.h>
+#import <CSSLayout/Yoga.h>
+
+@interface UIView (Yoga)
+
+/**
+  The property that decides if we should include this view when calculating layout. Defaults to YES.
+ */
+@property (nonatomic, readwrite, assign, setter=yg_setIncludeInLayout:) BOOL yg_includeInLayout;
+
+/**
+ The property that decides during layout/sizing whether or not yg_* properties should be applied. Defaults to NO.
+ */
+@property (nonatomic, readwrite, assign, setter=yg_setUsesYoga:) BOOL yg_usesYoga;
+
+- (void)yg_setDirection:(YGDirection)direction;
+- (void)yg_setFlexDirection:(YGFlexDirection)flexDirection;
+- (void)yg_setJustifyContent:(YGJustify)justifyContent;
+- (void)yg_setAlignContent:(YGAlign)alignContent;
+- (void)yg_setAlignItems:(YGAlign)alignItems;
+- (void)yg_setAlignSelf:(YGAlign)alignSelf;
+- (void)yg_setPositionType:(YGPositionType)positionType;
+- (void)yg_setFlexWrap:(YGWrap)flexWrap;
+
+- (void)yg_setFlexGrow:(CGFloat)flexGrow;
+- (void)yg_setFlexShrink:(CGFloat)flexShrink;
+- (void)yg_setFlexBasis:(CGFloat)flexBasis;
+
+- (void)yg_setPosition:(CGFloat)position forEdge:(YGEdge)edge;
+- (void)yg_setMargin:(CGFloat)margin forEdge:(YGEdge)edge;
+- (void)yg_setPadding:(CGFloat)padding forEdge:(YGEdge)edge;
+
+- (void)yg_setWidth:(CGFloat)width;
+- (void)yg_setHeight:(CGFloat)height;
+- (void)yg_setMinWidth:(CGFloat)minWidth;
+- (void)yg_setMinHeight:(CGFloat)minHeight;
+- (void)yg_setMaxWidth:(CGFloat)maxWidth;
+- (void)yg_setMaxHeight:(CGFloat)maxHeight;
+
+// Yoga specific properties, not compatible with flexbox specification
+- (void)yg_setAspectRatio:(CGFloat)aspectRatio;
+
+/**
+ Get the resolved direction of this node. This won't be YGDirectionInherit
+ */
+- (YGDirection)yg_resolvedDirection;
+
+/**
+ Perform a layout calculation and update the frames of the views in the hierarchy with th results
+ */
+- (void)yg_applyLayout;
+
+/**
+ Returns the size of the view if no constraints were given. This could equivalent to calling [self sizeThatFits:CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX)];
+ */
+- (CGSize)yg_intrinsicSize;
+
+/**
+ Returns the number of children that are using Flexbox.
+ */
+- (NSUInteger)yg_numberOfChildren;
+
+@end

YogaKit/UIView+Yoga.m

@@ -0,0 +1,379 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "UIView+Yoga.h"
+
+#import <objc/runtime.h>
+
+@interface YGNodeBridge : NSObject
+@property (nonatomic, assign, readonly) YGNodeRef cnode;
+@end
+
+@implementation YGNodeBridge
+
++ (void)initialize
+{
+  YogaSetExperimentalFeatureEnabled(YGExperimentalFeatureWebFlexBasis, true);
+}
+
+- (instancetype)init
+{
+  if ([super init]) {
+    _cnode = YGNodeNew();
+  }
+
+  return self;
+}
+
+- (void)dealloc
+{
+  YGNodeFree(_cnode);
+}
+@end
+
+@implementation UIView (Yoga)
+
+- (BOOL)yg_usesYoga
+{
+  NSNumber *usesYoga = objc_getAssociatedObject(self, @selector(yg_usesYoga));
+  return [usesYoga boolValue];
+}
+
+- (BOOL)yg_includeInLayout
+{
+  NSNumber *includeInLayout = objc_getAssociatedObject(self, @selector(yg_includeInLayout));
+  return (includeInLayout != nil) ? [includeInLayout boolValue] : YES;
+}
+
+- (NSUInteger)yg_numberOfChildren
+{
+  return YGNodeChildCount([self ygNode]);
+}
+
+#pragma mark - Setters
+
+- (void)yg_setIncludeInLayout:(BOOL)includeInLayout
+{
+  objc_setAssociatedObject(
+    self,
+    @selector(yg_includeInLayout),
+    @(includeInLayout),
+    OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+- (void)yg_setUsesYoga:(BOOL)enabled
+{
+  objc_setAssociatedObject(
+    self,
+    @selector(yg_usesYoga),
+    @(enabled),
+    OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+- (void)yg_setDirection:(YGDirection)direction
+{
+  YGNodeStyleSetDirection([self ygNode], direction);
+}
+
+- (void)yg_setFlexDirection:(YGFlexDirection)flexDirection
+{
+  YGNodeStyleSetFlexDirection([self ygNode], flexDirection);
+}
+
+- (void)yg_setJustifyContent:(YGJustify)justifyContent
+{
+  YGNodeStyleSetJustifyContent([self ygNode], justifyContent);
+}
+
+- (void)yg_setAlignContent:(YGAlign)alignContent
+{
+  YGNodeStyleSetAlignContent([self ygNode], alignContent);
+}
+
+- (void)yg_setAlignItems:(YGAlign)alignItems
+{
+  YGNodeStyleSetAlignItems([self ygNode], alignItems);
+}
+
+- (void)yg_setAlignSelf:(YGAlign)alignSelf
+{
+  YGNodeStyleSetAlignSelf([self ygNode], alignSelf);
+}
+
+- (void)yg_setPositionType:(YGPositionType)positionType
+{
+  YGNodeStyleSetPositionType([self ygNode], positionType);
+}
+
+- (void)yg_setFlexWrap:(YGWrap)flexWrap
+{
+  YGNodeStyleSetFlexWrap([self ygNode], flexWrap);
+}
+
+- (void)yg_setFlexGrow:(CGFloat)flexGrow
+{
+  YGNodeStyleSetFlexGrow([self ygNode], flexGrow);
+}
+
+- (void)yg_setFlexShrink:(CGFloat)flexShrink
+{
+  YGNodeStyleSetFlexShrink([self ygNode], flexShrink);
+}
+
+- (void)yg_setFlexBasis:(CGFloat)flexBasis
+{
+  YGNodeStyleSetFlexBasis([self ygNode], flexBasis);
+}
+
+- (void)yg_setPosition:(CGFloat)position forEdge:(YGEdge)edge
+{
+  YGNodeStyleSetPosition([self ygNode], edge, position);
+}
+
+- (void)yg_setMargin:(CGFloat)margin forEdge:(YGEdge)edge
+{
+  YGNodeStyleSetMargin([self ygNode], edge, margin);
+}
+
+- (void)yg_setPadding:(CGFloat)padding forEdge:(YGEdge)edge
+{
+  YGNodeStyleSetPadding([self ygNode], edge, padding);
+}
+
+- (void)yg_setWidth:(CGFloat)width
+{
+  YGNodeStyleSetWidth([self ygNode], width);
+}
+
+- (void)yg_setHeight:(CGFloat)height
+{
+  YGNodeStyleSetHeight([self ygNode], height);
+}
+
+- (void)yg_setMinWidth:(CGFloat)minWidth
+{
+  YGNodeStyleSetMinWidth([self ygNode], minWidth);
+}
+
+- (void)yg_setMinHeight:(CGFloat)minHeight
+{
+  YGNodeStyleSetMinHeight([self ygNode], minHeight);
+}
+
+- (void)yg_setMaxWidth:(CGFloat)maxWidth
+{
+  YGNodeStyleSetMaxWidth([self ygNode], maxWidth);
+}
+
+- (void)yg_setMaxHeight:(CGFloat)maxHeight
+{
+  YGNodeStyleSetMaxHeight([self ygNode], maxHeight);
+}
+
+- (void)yg_setAspectRatio:(CGFloat)aspectRatio
+{
+  YGNodeStyleSetAspectRatio([self ygNode], aspectRatio);
+}
+
+#pragma mark - Layout and Sizing
+
+- (YGDirection)yg_resolvedDirection
+{
+  return YGNodeLayoutGetDirection([self ygNode]);
+}
+
+- (void)yg_applyLayout
+{
+  [self calculateLayoutWithSize:self.bounds.size];
+  YGApplyLayoutToViewHierarchy(self);
+}
+
+- (CGSize)yg_intrinsicSize
+{
+  const CGSize constrainedSize = {
+      .width = YGUndefined,
+      .height = YGUndefined,
+  };
+  return [self calculateLayoutWithSize:constrainedSize];
+}
+
+#pragma mark - Private
+
+- (YGNodeRef)ygNode
+{
+  YGNodeBridge *node = objc_getAssociatedObject(self, @selector(ygNode));
+  if (!node) {
+    node = [YGNodeBridge new];
+    YGNodeSetContext(node.cnode, (__bridge void *) self);
+    objc_setAssociatedObject(self, @selector(ygNode), node, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+  }
+
+  return node.cnode;
+}
+
+- (CGSize)calculateLayoutWithSize:(CGSize)size
+{
+  NSAssert([NSThread isMainThread], @"YG Layout calculation must be done on main.");
+  NSAssert([self yg_usesYoga], @"YG Layout is not enabled for this view.");
+
+  YGAttachNodesFromViewHierachy(self);
+
+  const YGNodeRef node = [self ygNode];
+  YGNodeCalculateLayout(
+    node,
+    size.width,
+    size.height,
+    YGNodeStyleGetDirection(node));
+
+  return (CGSize) {
+    .width = YGNodeLayoutGetWidth(node),
+    .height = YGNodeLayoutGetHeight(node),
+  };
+}
+
+static YGSize YGMeasureView(
+  YGNodeRef node,
+  float width,
+  YGMeasureMode widthMode,
+  float height,
+  YGMeasureMode heightMode)
+{
+  const CGFloat constrainedWidth = (widthMode == YGMeasureModeUndefined) ? CGFLOAT_MAX : width;
+  const CGFloat constrainedHeight = (heightMode == YGMeasureModeUndefined) ? CGFLOAT_MAX: height;
+
+  UIView *view = (__bridge UIView*) YGNodeGetContext(node);
+  const CGSize sizeThatFits = [view sizeThatFits:(CGSize) {
+    .width = constrainedWidth,
+    .height = constrainedHeight,
+  }];
+
+  return (YGSize) {
+    .width = YGSanitizeMeasurement(constrainedWidth, sizeThatFits.width, widthMode),
+    .height = YGSanitizeMeasurement(constrainedHeight, sizeThatFits.height, heightMode),
+  };
+}
+
+static CGFloat YGSanitizeMeasurement(
+  CGFloat constrainedSize,
+  CGFloat measuredSize,
+  YGMeasureMode measureMode)
+{
+  CGFloat result;
+  if (measureMode == YGMeasureModeExactly) {
+    result = constrainedSize;
+  } else if (measureMode == YGMeasureModeAtMost) {
+    result = MIN(constrainedSize, measuredSize);
+  } else {
+    result = measuredSize;
+  }
+
+  return result;
+}
+
+static void YGAttachNodesFromViewHierachy(UIView *view) {
+  YGNodeRef node = [view ygNode];
+
+  // Only leaf nodes should have a measure function
+  if (![view yg_usesYoga] || view.subviews.count == 0) {
+    YGNodeSetMeasureFunc(node, YGMeasureView);
+    YGRemoveAllChildren(node);
+  } else {
+    YGNodeSetMeasureFunc(node, NULL);
+
+    // Create a list of all the subviews that we are going to use for layout.
+    NSMutableArray<UIView *> *subviewsToInclude = [[NSMutableArray alloc] initWithCapacity:view.subviews.count];
+    for (UIView *subview in view.subviews) {
+      if ([subview yg_includeInLayout]) {
+        [subviewsToInclude addObject:subview];
+      }
+    }
+
+    BOOL shouldReconstructChildList = NO;
+    if (YGNodeChildCount(node) != subviewsToInclude.count) {
+      shouldReconstructChildList = YES;
+    } else {
+      for (int i = 0; i < subviewsToInclude.count; i++) {
+        if (YGNodeGetChild(node, i) != [subviewsToInclude[i] ygNode]) {
+          shouldReconstructChildList = YES;
+          break;
+        }
+      }
+    }
+
+    if (shouldReconstructChildList) {
+      YGRemoveAllChildren(node);
+
+      for (int i = 0 ; i < subviewsToInclude.count; i++) {
+        UIView *const subview = subviewsToInclude[i];
+        YGNodeInsertChild(node, [subview ygNode], i);
+        YGAttachNodesFromViewHierachy(subview);
+      }
+    }
+  }
+}
+
+static void YGRemoveAllChildren(const YGNodeRef node)
+{
+  if (node == NULL) {
+      return;
+  }
+
+  while (YGNodeChildCount(node) > 0) {
+    YGNodeRemoveChild(node, YGNodeGetChild(node, YGNodeChildCount(node) - 1));
+  }
+}
+
+static CGFloat YGRoundPixelValue(CGFloat value)
+{
+  static CGFloat scale;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^(){
+    scale = [UIScreen mainScreen].scale;
+  });
+
+  return round(value * scale) / scale;
+}
+
+static void YGApplyLayoutToViewHierarchy(UIView *view) {
+  NSCAssert([NSThread isMainThread], @"Framesetting should only be done on the main thread.");
+  if (![view yg_includeInLayout]) {
+     return;
+  }
+
+  YGNodeRef node = [view ygNode];
+  const CGPoint topLeft = {
+    YGNodeLayoutGetLeft(node),
+    YGNodeLayoutGetTop(node),
+  };
+
+  const CGPoint bottomRight = {
+    topLeft.x + YGNodeLayoutGetWidth(node),
+    topLeft.y + YGNodeLayoutGetHeight(node),
+  };
+
+  view.frame = (CGRect) {
+    .origin = {
+      .x = YGRoundPixelValue(topLeft.x),
+      .y = YGRoundPixelValue(topLeft.y),
+    },
+    .size = {
+      .width = YGRoundPixelValue(bottomRight.x) - YGRoundPixelValue(topLeft.x),
+      .height = YGRoundPixelValue(bottomRight.y) - YGRoundPixelValue(topLeft.y),
+    },
+  };
+
+  const BOOL isLeaf = ![view yg_usesYoga] || view.subviews.count == 0;
+  if (!isLeaf) {
+    for (NSUInteger i = 0; i < view.subviews.count; i++) {
+      YGApplyLayoutToViewHierarchy(view.subviews[i]);
+    }
+  }
+}
+
+@end

benchmark/BUCK

@@ -0,0 +1,27 @@
+# Copyright (c) 2014-present, Facebook, Inc.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree. An additional grant
+# of patent rights can be found in the PATENTS file in the same directory.
+
+include_defs('//YOGA_DEFS')
+
+cxx_binary(
+  name = 'benchmark',
+  srcs = glob(['*.c']),
+  headers = subdir_glob([('', '*.h')]),
+  header_namespace = '',
+  compiler_flags = [
+    '-fno-omit-frame-pointer',
+    '-fexceptions',
+    '-Wall',
+    '-Werror',
+    '-O3',
+    '-std=c11',
+  ],
+  deps = [
+    csslayout_dep(':CSSLayout'),
+  ],
+  visibility = ['PUBLIC'],
+)

benchmark/YGBenchmark.c

@@ -0,0 +1,118 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include "YGBenchmark.h"
+
+#include <CSSLayout/Yoga.h>
+
+static YGSize _measure(YGNodeRef node,
+                        float width,
+                        YGMeasureMode widthMode,
+                        float height,
+                        YGMeasureMode heightMode) {
+  return (YGSize){
+      .width = widthMode == YGMeasureModeUndefined ? 10 : width,
+      .height = heightMode == YGMeasureModeUndefined ? 10 : width,
+  };
+}
+
+YGBENCHMARKS({
+
+  YGBENCHMARK("Stack with flex", {
+    const YGNodeRef root = YGNodeNew();
+    YGNodeStyleSetWidth(root, 100);
+    YGNodeStyleSetHeight(root, 100);
+
+    for (uint32_t i = 0; i < 10; i++) {
+      const YGNodeRef child = YGNodeNew();
+      YGNodeSetMeasureFunc(child, _measure);
+      YGNodeStyleSetFlex(child, 1);
+      YGNodeInsertChild(root, child, 0);
+    }
+
+    YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+    YGNodeFreeRecursive(root);
+  });
+
+  YGBENCHMARK("Align stretch in undefined axis", {
+    const YGNodeRef root = YGNodeNew();
+
+    for (uint32_t i = 0; i < 10; i++) {
+      const YGNodeRef child = YGNodeNew();
+      YGNodeStyleSetHeight(child, 20);
+      YGNodeSetMeasureFunc(child, _measure);
+      YGNodeInsertChild(root, child, 0);
+    }
+
+    YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+    YGNodeFreeRecursive(root);
+  });
+
+  YGBENCHMARK("Nested flex", {
+    const YGNodeRef root = YGNodeNew();
+
+    for (uint32_t i = 0; i < 10; i++) {
+      const YGNodeRef child = YGNodeNew();
+      YGNodeStyleSetFlex(child, 1);
+      YGNodeInsertChild(root, child, 0);
+
+      for (uint32_t ii = 0; ii < 10; ii++) {
+        const YGNodeRef grandChild = YGNodeNew();
+        YGNodeSetMeasureFunc(grandChild, _measure);
+        YGNodeStyleSetFlex(grandChild, 1);
+        YGNodeInsertChild(child, grandChild, 0);
+      }
+    }
+
+    YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+    YGNodeFreeRecursive(root);
+  });
+
+  YGBENCHMARK("Huge nested layout", {
+    const YGNodeRef root = YGNodeNew();
+
+    for (uint32_t i = 0; i < 10; i++) {
+      const YGNodeRef child = YGNodeNew();
+      YGNodeStyleSetFlexGrow(child, 1);
+      YGNodeStyleSetWidth(child, 10);
+      YGNodeStyleSetHeight(child, 10);
+      YGNodeInsertChild(root, child, 0);
+
+      for (uint32_t ii = 0; ii < 10; ii++) {
+        const YGNodeRef grandChild = YGNodeNew();
+        YGNodeStyleSetFlexDirection(grandChild, YGFlexDirectionRow);
+        YGNodeStyleSetFlexGrow(grandChild, 1);
+        YGNodeStyleSetWidth(grandChild, 10);
+        YGNodeStyleSetHeight(grandChild, 10);
+        YGNodeInsertChild(child, grandChild, 0);
+
+        for (uint32_t iii = 0; iii < 10; iii++) {
+          const YGNodeRef grandGrandChild = YGNodeNew();
+          YGNodeStyleSetFlexGrow(grandGrandChild, 1);
+          YGNodeStyleSetWidth(grandGrandChild, 10);
+          YGNodeStyleSetHeight(grandGrandChild, 10);
+          YGNodeInsertChild(grandChild, grandGrandChild, 0);
+
+          for (uint32_t iii = 0; iii < 10; iii++) {
+            const YGNodeRef grandGrandGrandChild = YGNodeNew();
+            YGNodeStyleSetFlexDirection(grandGrandGrandChild, YGFlexDirectionRow);
+            YGNodeStyleSetFlexGrow(grandGrandGrandChild, 1);
+            YGNodeStyleSetWidth(grandGrandGrandChild, 10);
+            YGNodeStyleSetHeight(grandGrandGrandChild, 10);
+            YGNodeInsertChild(grandGrandChild, grandGrandGrandChild, 0);
+          }
+        }
+      }
+    }
+
+    YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+    YGNodeFreeRecursive(root);
+  });
+
+});

benchmark/YGBenchmark.h

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define NUM_REPETITIONS 1000
+
+#define YGBENCHMARKS(BLOCK)              \
+  int main(int argc, char const *argv[]) { \
+    clock_t __start;                       \
+    clock_t __endTimes[NUM_REPETITIONS];   \
+    { BLOCK }                              \
+    return 0;                              \
+  }
+
+#define YGBENCHMARK(NAME, BLOCK)                       \
+  __start = clock();                                     \
+  for (uint32_t __i = 0; __i < NUM_REPETITIONS; __i++) { \
+    { BLOCK }                                            \
+    __endTimes[__i] = clock();                           \
+  }                                                      \
+  __printBenchmarkResult(NAME, __start, __endTimes);
+
+int __compareDoubles(const void *a, const void *b) {
+  double arg1 = *(const double *) a;
+  double arg2 = *(const double *) b;
+
+  if (arg1 < arg2) {
+    return -1;
+  }
+
+  if (arg1 > arg2) {
+    return 1;
+  }
+
+  return 0;
+}
+
+void __printBenchmarkResult(char *name, clock_t start, clock_t *endTimes) {
+  double timesInMs[NUM_REPETITIONS];
+  double mean = 0;
+  clock_t lastEnd = start;
+  for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
+    timesInMs[i] = (endTimes[i] - lastEnd) / (double) CLOCKS_PER_SEC * 1000;
+    lastEnd = endTimes[i];
+    mean += timesInMs[i];
+  }
+  mean /= NUM_REPETITIONS;
+
+  qsort(timesInMs, NUM_REPETITIONS, sizeof(double), __compareDoubles);
+  double median = timesInMs[NUM_REPETITIONS / 2];
+
+  double variance = 0;
+  for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
+    variance += pow(timesInMs[i] - mean, 2);
+  }
+  variance /= NUM_REPETITIONS;
+  double stddev = sqrt(variance);
+
+  printf("%s: median: %lf ms, stddev: %lf ms\n", name, median, stddev);
+}

csharp/.gitignore

@@ -0,0 +1,265 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+
+# Visual Studio 2015 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# DNX
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# TODO: Comment the next line if you want to checkin your web deploy settings
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/packages/repositories.config
+# NuGet v3's project.json files produces more ignoreable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+node_modules/
+orleans.codegen.cs
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# CodeRush
+.cr/
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc

csharp/.hgignore

@@ -0,0 +1,265 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+
+# Visual Studio 2015 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# DNX
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# TODO: Comment the next line if you want to checkin your web deploy settings
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/packages/repositories.config
+# NuGet v3's project.json files produces more ignoreable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+node_modules/
+orleans.codegen.cs
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# CodeRush
+.cr/
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc

csharp/BUCK

@@ -0,0 +1,20 @@
+# Copyright (c) 2014-present, Facebook, Inc.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree. An additional grant
+# of patent rights can be found in the PATENTS file in the same directory.
+
+csharp_library(
+  name = 'csslibnet46',
+  dll_name = 'Facebook.Yoga.dll',
+  framework_ver = 'net46',
+  srcs = glob(['**/*.cs']),
+)
+
+csharp_library(
+  name = 'csslibnet45',
+  dll_name = 'Facebook.Yoga.dll',
+  framework_ver = 'net45',
+  srcs = glob(['**/*.cs']),
+)

csharp/Facebook.Yoga.sln

@@ -0,0 +1,46 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Yoga", "Yoga\Yoga.vcxproj", "{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}"
+EndProject
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Facebook.Yoga", "Facebook.Yoga\Facebook.Yoga.xproj", "{75BB7605-E54B-4EDE-8F5A-FF1F24464236}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}.Debug|x64.ActiveCfg = Debug|x64
+		{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}.Debug|x64.Build.0 = Debug|x64
+		{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}.Debug|x86.ActiveCfg = Debug|Win32
+		{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}.Debug|x86.Build.0 = Debug|Win32
+		{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}.Release|Any CPU.ActiveCfg = Release|Win32
+		{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}.Release|x64.ActiveCfg = Release|x64
+		{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}.Release|x64.Build.0 = Release|x64
+		{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}.Release|x86.ActiveCfg = Release|Win32
+		{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}.Release|x86.Build.0 = Release|Win32
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Debug|x64.Build.0 = Debug|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Debug|x86.Build.0 = Debug|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Release|Any CPU.Build.0 = Release|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Release|x64.ActiveCfg = Release|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Release|x64.Build.0 = Release|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Release|x86.ActiveCfg = Release|Any CPU
+		{75BB7605-E54B-4EDE-8F5A-FF1F24464236}.Release|x86.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

csharp/Facebook.Yoga/Facebook.Yoga.xproj

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.Props" Condition="'$(VSToolsPath)' != ''" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>75bb7605-e54b-4ede-8f5a-ff1f24464236</ProjectGuid>
+    <RootNamespace>Facebook.Yoga</RootNamespace>
+    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">.\obj</BaseIntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)'=='' ">.\bin\</OutputPath>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.targets" Condition="'$(VSToolsPath)' != ''" />
+</Project>

csharp/Facebook.Yoga/MeasureFunction.cs

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public delegate long MeasureFunction(
+        YogaNode node,
+        float width,
+        YogaMeasureMode widthMode,
+        float height,
+        YogaMeasureMode heightMode);
+}

csharp/Facebook.Yoga/MeasureOutput.cs

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public class MeasureOutput
+    {
+        public static long Make(double width, double height)
+        {
+            return Make((int) width, (int) height);
+        }
+
+        public static long Make(int width, int height)
+        {
+            return (long)(((ulong) width) << 32 | ((uint) height));
+        }
+
+        public static int GetWidth(long measureOutput)
+        {
+            return (int) (0xFFFFFFFF & (measureOutput >> 32));
+        }
+
+        public static int GetHeight(long measureOutput)
+        {
+            return (int) (0xFFFFFFFF & measureOutput);
+        }
+    }
+}

csharp/Facebook.Yoga/Native.cs

@@ -0,0 +1,286 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Facebook.Yoga
+{
+    internal static class Native
+    {
+#if UNITY_IOS && !UNITY_EDITOR
+        private const string DllName = "__Internal";
+#else
+        private const string DllName = "yoga";
+#endif
+
+        [DllImport(DllName)]
+        public static extern void YGInteropSetLogger(
+            [MarshalAs(UnmanagedType.FunctionPtr)] YogaLogger.Func func);
+
+        [DllImport(DllName)]
+        public static extern IntPtr YGNodeNew();
+
+        [DllImport(DllName)]
+        public static extern void YGNodeInit(IntPtr cssNode);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeFree(IntPtr cssNode);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeReset(IntPtr cssNode);
+
+        [DllImport(DllName)]
+        public static extern int YGNodeGetInstanceCount();
+
+        [DllImport(DllName)]
+        public static extern void YGSetExperimentalFeatureEnabled(
+            YogaExperimentalFeature feature,
+            bool enabled);
+
+        [DllImport(DllName)]
+        public static extern bool YGIsExperimentalFeatureEnabled(
+            YogaExperimentalFeature feature);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeInsertChild(IntPtr node, IntPtr child, uint index);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeRemoveChild(IntPtr node, IntPtr child);
+
+        [DllImport(DllName)]
+        public static extern IntPtr YGNodeGetChild(IntPtr node, uint index);
+
+        [DllImport(DllName)]
+        public static extern uint YGNodeChildCount(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeCalculateLayout(IntPtr node,
+                            float availableWidth,
+                            float availableHeight,
+                            YogaDirection parentDirection);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeMarkDirty(IntPtr node);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.I1)]
+        public static extern bool YGNodeIsDirty(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodePrint(IntPtr node, YogaPrintOptions options);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.I1)]
+        public static extern bool YGValueIsUndefined(float value);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeCopyStyle(IntPtr dstNode, IntPtr srcNode);
+
+        #region YG_NODE_PROPERTY
+
+        [DllImport(DllName)]
+        public static extern void YGNodeSetContext(IntPtr node, IntPtr context);
+
+        [DllImport(DllName)]
+        public static extern IntPtr YGNodeGetContext(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeSetMeasureFunc(
+            IntPtr node,
+            [MarshalAs(UnmanagedType.FunctionPtr)] YogaMeasureFunc measureFunc);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.FunctionPtr)]
+        public static extern YogaMeasureFunc YGNodeGetMeasureFunc(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeSetHasNewLayout(IntPtr node, [MarshalAs(UnmanagedType.I1)] bool hasNewLayout);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.I1)]
+        public static extern bool YGNodeGetHasNewLayout(IntPtr node);
+
+        #endregion
+
+        #region YG_NODE_STYLE_PROPERTY
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetDirection(IntPtr node, YogaDirection direction);
+
+        [DllImport(DllName)]
+        public static extern YogaDirection YGNodeStyleGetDirection(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetFlexDirection(IntPtr node, YogaFlexDirection flexDirection);
+
+        [DllImport(DllName)]
+        public static extern YogaFlexDirection YGNodeStyleGetFlexDirection(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetJustifyContent(IntPtr node, YogaJustify justifyContent);
+
+        [DllImport(DllName)]
+        public static extern YogaJustify YGNodeStyleGetJustifyContent(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetAlignContent(IntPtr node, YogaAlign alignContent);
+
+        [DllImport(DllName)]
+        public static extern YogaAlign YGNodeStyleGetAlignContent(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetAlignItems(IntPtr node, YogaAlign alignItems);
+
+        [DllImport(DllName)]
+        public static extern YogaAlign YGNodeStyleGetAlignItems(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetAlignSelf(IntPtr node, YogaAlign alignSelf);
+
+        [DllImport(DllName)]
+        public static extern YogaAlign YGNodeStyleGetAlignSelf(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetPositionType(IntPtr node, YogaPositionType positionType);
+
+        [DllImport(DllName)]
+        public static extern YogaPositionType YGNodeStyleGetPositionType(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetFlexWrap(IntPtr node, YogaWrap flexWrap);
+
+        [DllImport(DllName)]
+        public static extern YogaWrap YGNodeStyleGetFlexWrap(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetOverflow(IntPtr node, YogaOverflow flexWrap);
+
+        [DllImport(DllName)]
+        public static extern YogaOverflow YGNodeStyleGetOverflow(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetFlex(IntPtr node, float flex);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetFlexGrow(IntPtr node, float flexGrow);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetFlexGrow(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetFlexShrink(IntPtr node, float flexShrink);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetFlexShrink(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetFlexBasis(IntPtr node, float flexBasis);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetFlexBasis(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetWidth(IntPtr node, float width);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetWidth(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetHeight(IntPtr node, float height);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetHeight(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetMinWidth(IntPtr node, float minWidth);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetMinWidth(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetMinHeight(IntPtr node, float minHeight);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetMinHeight(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetMaxWidth(IntPtr node, float maxWidth);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetMaxWidth(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetMaxHeight(IntPtr node, float maxHeight);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetMaxHeight(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetAspectRatio(IntPtr node, float aspectRatio);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetAspectRatio(IntPtr node);
+
+        #endregion
+
+        #region YG_NODE_STYLE_EDGE_PROPERTY
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetPosition(IntPtr node, YogaEdge edge, float position);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetPosition(IntPtr node, YogaEdge edge);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetMargin(IntPtr node, YogaEdge edge, float margin);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetMargin(IntPtr node, YogaEdge edge);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetPadding(IntPtr node, YogaEdge edge, float padding);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetPadding(IntPtr node, YogaEdge edge);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeStyleSetBorder(IntPtr node, YogaEdge edge, float border);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeStyleGetBorder(IntPtr node, YogaEdge edge);
+
+        #endregion
+
+        #region YG_NODE_LAYOUT_PROPERTY
+
+        [DllImport(DllName)]
+        public static extern float YGNodeLayoutGetLeft(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeLayoutGetTop(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeLayoutGetRight(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeLayoutGetBottom(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeLayoutGetWidth(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern float YGNodeLayoutGetHeight(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern YogaDirection YGNodeLayoutGetDirection(IntPtr node);
+
+        #endregion
+    }
+}

csharp/Facebook.Yoga/Properties/AssemblyInfo.cs

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System.Reflection;
+using System.Resources;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Facebook, Inc.")]
+[assembly: AssemblyProduct("Facebook.Yoga")]
+[assembly: AssemblyTrademark("Copyright (c) 2014-present, Facebook, Inc.")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("75bb7605-e54b-4ede-8f5a-ff1f24464236")]
+
+[assembly: NeutralResourcesLanguage("en")]
+
+[assembly: AssemblyVersion("3.0.0.0")]

csharp/Facebook.Yoga/Spacing.cs

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public class Spacing
+    {
+        public float? Top;
+        public float? Bottom;
+        public float? Left;
+        public float? Right;
+
+        public Spacing(
+            float? top = null,
+            float? bottom = null,
+            float? left = null,
+            float? right = null)
+        {
+            Top = top;
+            Bottom = bottom;
+            Left = left;
+            Right = right;
+        }
+    }
+}

csharp/Facebook.Yoga/YogaAlign.cs

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaAlign
+    {
+        Auto,
+        FlexStart,
+        Center,
+        FlexEnd,
+        Stretch,
+    }
+}

csharp/Facebook.Yoga/YogaConstants.cs

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public static class YogaConstants
+    {
+        public const float Undefined = float.NaN;
+
+        public static bool IsUndefined(float value)
+        {
+            return float.IsNaN(value);
+        }
+    }
+}

csharp/Facebook.Yoga/YogaDimension.cs

@@ -1,17 +1,17 @@
 /**
- * Copyright (c) 2014, Facebook, Inc.
+ * Copyright (c) 2014-present, Facebook, Inc.
  * All rights reserved.
  *
  * This source code is licensed under the BSD-style license found in the
  * LICENSE file in the root directory of this source tree. An additional grant
  * of patent rights can be found in the PATENTS file in the same directory.
  */
-package com.facebook.csslayout;
 
-public enum CSSAlign {
-  AUTO,
-  FLEX_START,
-  CENTER,
-  FLEX_END,
-  STRETCH,
+namespace Facebook.Yoga
+{
+    public enum YogaDimension
+    {
+        Width,
+        Height,
+    }
 }

csharp/Facebook.Yoga/YogaDirection.cs

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaDirection
+    {
+        Inherit,
+        LTR,
+        RTL,
+    }
+}

csharp/Facebook.Yoga/YogaEdge.cs

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaEdge
+    {
+        Left,
+        Top,
+        Right,
+        Bottom,
+        Start,
+        End,
+        Horizontal,
+        Vertical,
+        All,
+    }
+}

csharp/Facebook.Yoga/YogaExperimentalFeature.cs

@@ -1,17 +1,17 @@
 /**
- * Copyright (c) 2014, Facebook, Inc.
+ * Copyright (c) 2014-present, Facebook, Inc.
  * All rights reserved.
  *
  * This source code is licensed under the BSD-style license found in the
  * LICENSE file in the root directory of this source tree. An additional grant
  * of patent rights can be found in the PATENTS file in the same directory.
  */
-package com.facebook.csslayout;
 
-public enum CSSJustify {
-  FLEX_START,
-  CENTER,
-  FLEX_END,
-  SPACE_BETWEEN,
-  SPACE_AROUND,
+namespace Facebook.Yoga
+{
+    public enum YogaExperimentalFeature
+    {
+        Rounding,
+        WebFlexBasis,
+    }
 }

csharp/Facebook.Yoga/YogaFlexDirection.cs

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaFlexDirection
+    {
+        Column,
+        ColumnReverse,
+        Row,
+        RowReverse,
+    }
+}

csharp/Facebook.Yoga/YogaJustify.cs

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaJustify
+    {
+        FlexStart,
+        Center,
+        FlexEnd,
+        SpaceBetween,
+        SpaceAround,
+    }
+}

csharp/Facebook.Yoga/YogaLogLevel.cs

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaLogLevel
+    {
+        Error,
+        Warn,
+        Info,
+        Debug,
+        Verbose,
+    }
+}

csharp/Facebook.Yoga/YogaLogger.cs

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Facebook.Yoga
+{
+    internal static class YogaLogger
+    {
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void Func(YogaLogLevel level, string message);
+
+        private static bool _initialized;
+        private static Func _managedLogger = null;
+
+        public static Func Logger = null;
+
+        public static void Initialize()
+        {
+            if (!_initialized)
+            {
+                _managedLogger = (level, message) => {
+                    if (Logger != null)
+                    {
+                        Logger(level, message);
+                    }
+
+                    if (level == YogaLogLevel.Error)
+                    {
+                        throw new InvalidOperationException(message);
+                    }
+                };
+                Native.YGInteropSetLogger(_managedLogger);
+                _initialized = true;
+            }
+        }
+    }
+}

csharp/Facebook.Yoga/YogaMeasureFunc.cs

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Facebook.Yoga
+{
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate YogaSize YogaMeasureFunc(
+        IntPtr node,
+        float width,
+        YogaMeasureMode widthMode,
+        float height,
+        YogaMeasureMode heightMode);
+}

csharp/Facebook.Yoga/YogaMeasureMode.cs

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaMeasureMode
+    {
+        Undefined,
+        Exactly,
+        AtMost,
+    }
+}

csharp/Facebook.Yoga/YogaNode.Create.cs

@@ -0,0 +1,233 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System;
+
+namespace Facebook.Yoga
+{
+    public partial class YogaNode
+    {
+        public static YogaNode Create(
+            YogaDirection? styleDirection = null,
+            YogaFlexDirection? flexDirection = null,
+            YogaJustify? justifyContent = null,
+            YogaAlign? alignContent = null,
+            YogaAlign? alignItems = null,
+            YogaAlign? alignSelf = null,
+            YogaPositionType? positionType = null,
+            YogaWrap? wrap = null,
+            YogaOverflow? overflow = null,
+            float? flex = null,
+            float? flexGrow = null,
+            float? flexShrink = null,
+            float? flexBasis = null,
+            Spacing position = null,
+            Spacing margin = null,
+            Spacing padding = null,
+            Spacing border = null,
+            float? Width = null,
+            float? Height = null,
+            float? MaxWidth = null,
+            float? MaxHeight = null,
+            float? MinWidth = null,
+            float? MinHeight = null)
+        {
+            YogaNode node = new YogaNode();
+
+            if (styleDirection.HasValue)
+            {
+                node.StyleDirection = styleDirection.Value;
+            }
+
+            if (flexDirection.HasValue)
+            {
+                node.FlexDirection = flexDirection.Value;
+            }
+
+            if (justifyContent.HasValue)
+            {
+                node.JustifyContent = justifyContent.Value;
+            }
+
+            if (alignContent.HasValue)
+            {
+                node.AlignContent = alignContent.Value;
+            }
+
+            if (alignItems.HasValue)
+            {
+                node.AlignItems = alignItems.Value;
+            }
+
+            if (alignSelf.HasValue)
+            {
+                node.AlignSelf = alignSelf.Value;
+            }
+
+            if (positionType.HasValue)
+            {
+                node.PositionType = positionType.Value;
+            }
+
+            if (wrap.HasValue)
+            {
+                node.Wrap = wrap.Value;
+            }
+
+            if (overflow.HasValue)
+            {
+                node.Overflow = overflow.Value;
+            }
+
+            if (flex.HasValue)
+            {
+                node.Flex = flex.Value;
+            }
+
+            if (flexGrow.HasValue)
+            {
+                node.FlexGrow = flexGrow.Value;
+            }
+
+            if (flexShrink.HasValue)
+            {
+                node.FlexShrink = flexShrink.Value;
+            }
+
+            if (flexBasis.HasValue)
+            {
+                node.FlexBasis = flexBasis.Value;
+            }
+
+            if (position != null)
+            {
+                if (position.Top.HasValue)
+                {
+                    node.SetPosition(YogaEdge.Top, position.Top.Value);
+                }
+
+                if (position.Bottom.HasValue)
+                {
+                    node.SetPosition(YogaEdge.Bottom, position.Bottom.Value);
+                }
+
+                if (position.Left.HasValue)
+                {
+                    node.SetPosition(YogaEdge.Left, position.Left.Value);
+                }
+
+                if (position.Right.HasValue)
+                {
+                    node.SetPosition(YogaEdge.Right, position.Right.Value);
+                }
+            }
+
+            if (margin != null)
+            {
+                if (margin.Top.HasValue)
+                {
+                    node.SetMargin(YogaEdge.Top, margin.Top.Value);
+                }
+
+                if (margin.Bottom.HasValue)
+                {
+                    node.SetMargin(YogaEdge.Bottom, margin.Bottom.Value);
+                }
+
+                if (margin.Left.HasValue)
+                {
+                    node.SetMargin(YogaEdge.Left, margin.Left.Value);
+                }
+
+                if (margin.Right.HasValue)
+                {
+                    node.SetMargin(YogaEdge.Right, margin.Right.Value);
+                }
+            }
+
+            if (padding != null)
+            {
+                if (padding.Top.HasValue)
+                {
+                    node.SetPadding(YogaEdge.Top, padding.Top.Value);
+                }
+
+                if (padding.Bottom.HasValue)
+                {
+                    node.SetPadding(YogaEdge.Bottom, padding.Bottom.Value);
+                }
+
+                if (padding.Left.HasValue)
+                {
+                    node.SetPadding(YogaEdge.Left, padding.Left.Value);
+                }
+
+                if (padding.Right.HasValue)
+                {
+                    node.SetPadding(YogaEdge.Right, padding.Right.Value);
+                }
+            }
+
+            if (border != null)
+            {
+                if (border.Top.HasValue)
+                {
+                    node.SetBorder(YogaEdge.Top, border.Top.Value);
+                }
+
+                if (border.Bottom.HasValue)
+                {
+                    node.SetBorder(YogaEdge.Bottom, border.Bottom.Value);
+                }
+
+                if (border.Left.HasValue)
+                {
+                    node.SetBorder(YogaEdge.Left, border.Left.Value);
+                }
+
+                if (border.Right.HasValue)
+                {
+                    node.SetBorder(YogaEdge.Right, border.Right.Value);
+                }
+            }
+
+            if (Width.HasValue)
+            {
+                node.Width = Width.Value;
+            }
+
+            if (Height.HasValue)
+            {
+                node.Height = Height.Value;
+            }
+
+            if (MinWidth.HasValue)
+            {
+                node.MinWidth = MinWidth.Value;
+            }
+
+            if (MinHeight.HasValue)
+            {
+                node.MinHeight = MinHeight.Value;
+            }
+
+            if (MaxWidth.HasValue)
+            {
+                node.MaxWidth = MaxWidth.Value;
+            }
+
+            if (MaxHeight.HasValue)
+            {
+                node.MaxHeight = MaxHeight.Value;
+            }
+
+            return node;
+        }
+    }
+}

csharp/Facebook.Yoga/YogaNode.cs

@@ -0,0 +1,584 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Facebook.Yoga
+{
+    public partial class YogaNode : IEnumerable<YogaNode>
+    {
+        private IntPtr _ygNode;
+        private WeakReference _parent;
+        private List<YogaNode> _children;
+        private MeasureFunction _measureFunction;
+        private YogaMeasureFunc _ygMeasureFunc;
+        private object _data;
+
+        public YogaNode()
+        {
+            YogaLogger.Initialize();
+
+            _ygNode = Native.YGNodeNew();
+            if (_ygNode == IntPtr.Zero)
+            {
+                throw new InvalidOperationException("Failed to allocate native memory");
+            }
+        }
+
+        ~YogaNode()
+        {
+            Native.YGNodeFree(_ygNode);
+        }
+
+        public void Reset()
+        {
+            _measureFunction = null;
+            _data = null;
+
+            Native.YGNodeReset(_ygNode);
+        }
+
+        public bool IsDirty
+        {
+            get
+            {
+                return Native.YGNodeIsDirty(_ygNode);
+            }
+        }
+
+        public virtual void MarkDirty()
+        {
+            Native.YGNodeMarkDirty(_ygNode);
+        }
+
+        public bool HasNewLayout
+        {
+            get
+            {
+                return Native.YGNodeGetHasNewLayout(_ygNode);
+            }
+        }
+
+        public void MarkHasNewLayout()
+        {
+            Native.YGNodeSetHasNewLayout(_ygNode, true);
+        }
+
+        public YogaNode Parent
+        {
+            get
+            {
+                return _parent != null ? _parent.Target as YogaNode : null;
+            }
+        }
+
+        public bool IsMeasureDefined
+        {
+            get
+            {
+                return _measureFunction != null;
+            }
+        }
+
+        public void CopyStyle(YogaNode srcNode)
+        {
+            Native.YGNodeCopyStyle(_ygNode, srcNode._ygNode);
+        }
+
+        public YogaDirection StyleDirection
+        {
+            get
+            {
+                return Native.YGNodeStyleGetDirection(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetDirection(_ygNode, value);
+            }
+        }
+
+        public YogaFlexDirection FlexDirection
+        {
+            get
+            {
+                return Native.YGNodeStyleGetFlexDirection(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetFlexDirection(_ygNode, value);
+            }
+        }
+
+        public YogaJustify JustifyContent
+        {
+            get
+            {
+                return Native.YGNodeStyleGetJustifyContent(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetJustifyContent(_ygNode, value);
+            }
+        }
+
+        public YogaAlign AlignItems
+        {
+            get
+            {
+                return Native.YGNodeStyleGetAlignItems(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetAlignItems(_ygNode, value);
+            }
+        }
+
+        public YogaAlign AlignSelf
+        {
+            get
+            {
+                return Native.YGNodeStyleGetAlignSelf(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetAlignSelf(_ygNode, value);
+            }
+        }
+
+        public YogaAlign AlignContent
+        {
+            get
+            {
+                return Native.YGNodeStyleGetAlignContent(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetAlignContent(_ygNode, value);
+            }
+        }
+
+        public YogaPositionType PositionType
+        {
+            get
+            {
+                return Native.YGNodeStyleGetPositionType(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetPositionType(_ygNode, value);
+            }
+        }
+
+        public YogaWrap Wrap
+        {
+            get
+            {
+                return Native.YGNodeStyleGetFlexWrap(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetFlexWrap(_ygNode, value);
+            }
+        }
+
+        public float Flex
+        {
+            set
+            {
+                Native.YGNodeStyleSetFlex(_ygNode, value);
+            }
+        }
+
+        public float FlexGrow
+        {
+            get
+            {
+                return Native.YGNodeStyleGetFlexGrow(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetFlexGrow(_ygNode, value);
+            }
+        }
+
+        public float FlexShrink
+        {
+            get
+            {
+                return Native.YGNodeStyleGetFlexShrink(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetFlexShrink(_ygNode, value);
+            }
+        }
+
+        public float FlexBasis
+        {
+            get
+            {
+                return Native.YGNodeStyleGetFlexBasis(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetFlexBasis(_ygNode, value);
+            }
+        }
+
+        public float GetMargin(YogaEdge edge)
+        {
+            return Native.YGNodeStyleGetMargin(_ygNode, edge);
+        }
+
+        public void SetMargin(YogaEdge edge, float value)
+        {
+            Native.YGNodeStyleSetMargin(_ygNode, edge, value);
+        }
+
+        public float GetPadding(YogaEdge edge)
+        {
+            return Native.YGNodeStyleGetPadding(_ygNode, edge);
+        }
+
+        public void SetPadding(YogaEdge edge, float padding)
+        {
+            Native.YGNodeStyleSetPadding(_ygNode, edge, padding);
+        }
+
+        public float GetBorder(YogaEdge edge)
+        {
+            return Native.YGNodeStyleGetBorder(_ygNode, edge);
+        }
+
+        public void SetBorder(YogaEdge edge, float border)
+        {
+            Native.YGNodeStyleSetBorder(_ygNode, edge, border);
+        }
+
+        public float GetPosition(YogaEdge edge)
+        {
+            return Native.YGNodeStyleGetPosition(_ygNode, edge);
+        }
+
+        public void SetPosition(YogaEdge edge, float position)
+        {
+            Native.YGNodeStyleSetPosition(_ygNode, edge, position);
+        }
+
+        public float Width
+        {
+            get
+            {
+                return Native.YGNodeStyleGetWidth(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetWidth(_ygNode, value);
+            }
+        }
+
+        public float Height
+        {
+            get
+            {
+                return Native.YGNodeStyleGetHeight(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetHeight(_ygNode, value);
+            }
+        }
+
+        public float MaxWidth
+        {
+            get
+            {
+                return Native.YGNodeStyleGetMaxWidth(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetMaxWidth(_ygNode, value);
+            }
+        }
+
+        public float MaxHeight
+        {
+            get
+            {
+                return Native.YGNodeStyleGetMaxHeight(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetMaxHeight(_ygNode, value);
+            }
+        }
+
+        public float MinWidth
+        {
+            get
+            {
+                return Native.YGNodeStyleGetMinWidth(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetMinWidth(_ygNode, value);
+            }
+        }
+
+        public float MinHeight
+        {
+            get
+            {
+                return Native.YGNodeStyleGetMinHeight(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetMinHeight(_ygNode, value);
+            }
+        }
+
+        public float StyleAspectRatio
+        {
+            get
+            {
+                return Native.YGNodeStyleGetAspectRatio(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetAspectRatio(_ygNode, value);
+            }
+        }
+
+        public float LayoutX
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetLeft(_ygNode);
+            }
+        }
+
+        public float LayoutY
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetTop(_ygNode);
+            }
+        }
+
+        public float LayoutWidth
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetWidth(_ygNode);
+            }
+        }
+
+        public float LayoutHeight
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetHeight(_ygNode);
+            }
+        }
+
+        public YogaDirection LayoutDirection
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetDirection(_ygNode);
+            }
+        }
+
+        public YogaOverflow Overflow
+        {
+            get
+            {
+                return Native.YGNodeStyleGetOverflow(_ygNode);
+            }
+
+            set
+            {
+                Native.YGNodeStyleSetOverflow(_ygNode, value);
+            }
+        }
+
+        public object Data
+        {
+            get
+            {
+                return _data;
+            }
+
+            set
+            {
+                _data = value;
+            }
+        }
+
+        public YogaNode this[int index]
+        {
+            get
+            {
+                return _children[index];
+            }
+        }
+
+        public int Count
+        {
+            get
+            {
+                return _children != null ? _children.Count : 0;
+            }
+        }
+
+        public void MarkLayoutSeen()
+        {
+            Native.YGNodeSetHasNewLayout(_ygNode, false);
+        }
+
+        public bool ValuesEqual(float f1, float f2)
+        {
+            if (float.IsNaN(f1) || float.IsNaN(f2))
+            {
+                return float.IsNaN(f1) && float.IsNaN(f2);
+            }
+
+            return Math.Abs(f2 - f1) < float.Epsilon;
+        }
+
+        public void Insert(int index, YogaNode node)
+        {
+            if (_children == null)
+            {
+                _children = new List<YogaNode>(4);
+            }
+            _children.Insert(index, node);
+            node._parent = new WeakReference(this);
+            Native.YGNodeInsertChild(_ygNode, node._ygNode, (uint)index);
+        }
+
+        public void RemoveAt(int index)
+        {
+            var child = _children[index];
+            child._parent = null;
+            _children.RemoveAt(index);
+            Native.YGNodeRemoveChild(_ygNode, child._ygNode);
+        }
+
+        public void Clear()
+        {
+            if (_children != null)
+            {
+                while (_children.Count > 0)
+                {
+                    RemoveAt(_children.Count-1);
+                }
+            }
+        }
+
+        public int IndexOf(YogaNode node)
+        {
+            return _children != null ? _children.IndexOf(node) : -1;
+        }
+
+        public void SetMeasureFunction(MeasureFunction measureFunction)
+        {
+            _measureFunction = measureFunction;
+            _ygMeasureFunc = measureFunction != null ? MeasureInternal : (YogaMeasureFunc)null;
+            Native.YGNodeSetMeasureFunc(_ygNode, _ygMeasureFunc);
+        }
+
+        public void CalculateLayout()
+        {
+            Native.YGNodeCalculateLayout(
+                _ygNode,
+                YogaConstants.Undefined,
+                YogaConstants.Undefined,
+                Native.YGNodeStyleGetDirection(_ygNode));
+        }
+
+        private YogaSize MeasureInternal(
+            IntPtr node,
+            float width,
+            YogaMeasureMode widthMode,
+            float height,
+            YogaMeasureMode heightMode)
+        {
+            if (_measureFunction == null)
+            {
+                throw new InvalidOperationException("Measure function is not defined.");
+            }
+
+            long output = _measureFunction(this, width, widthMode, height, heightMode);
+            return new YogaSize { width = MeasureOutput.GetWidth(output), height = MeasureOutput.GetHeight(output) };
+        }
+
+        public string Print(YogaPrintOptions options =
+            YogaPrintOptions.Layout|YogaPrintOptions.Style|YogaPrintOptions.Children)
+        {
+            StringBuilder sb = new StringBuilder();
+            YogaLogger.Func orig = YogaLogger.Logger;
+            YogaLogger.Logger = (level, message) => {sb.Append(message);};
+            Native.YGNodePrint(_ygNode, options);
+            YogaLogger.Logger = orig;
+            return sb.ToString();
+        }
+
+        public IEnumerator<YogaNode> GetEnumerator()
+        {
+            return _children != null ? ((IEnumerable<YogaNode>)_children).GetEnumerator() :
+                System.Linq.Enumerable.Empty<YogaNode>().GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return _children != null ? ((IEnumerable<YogaNode>)_children).GetEnumerator() :
+                System.Linq.Enumerable.Empty<YogaNode>().GetEnumerator();
+        }
+
+        public static int GetInstanceCount()
+        {
+            return Native.YGNodeGetInstanceCount();
+        }
+
+        public static void SetExperimentalFeatureEnabled(
+            YogaExperimentalFeature feature,
+            bool enabled)
+        {
+            Native.YGSetExperimentalFeatureEnabled(feature, enabled);
+        }
+
+        public static bool IsExperimentalFeatureEnabled(YogaExperimentalFeature feature)
+        {
+            return Native.YGIsExperimentalFeatureEnabled(feature);
+        }
+    }
+}

csharp/Facebook.Yoga/YogaOverflow.cs

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaOverflow
+    {
+        Visible,
+        Hidden,
+        Scroll,
+    }
+}

csharp/Facebook.Yoga/YogaPositionType.cs

@@ -1,16 +1,17 @@
 /**
- * Copyright (c) 2014, Facebook, Inc.
+ * Copyright (c) 2014-present, Facebook, Inc.
  * All rights reserved.
  *
  * This source code is licensed under the BSD-style license found in the
  * LICENSE file in the root directory of this source tree. An additional grant
  * of patent rights can be found in the PATENTS file in the same directory.
  */
-package com.facebook.csslayout;
 
-public enum CSSFlexDirection {
-  COLUMN,
-  COLUMN_REVERSE,
-  ROW,
-  ROW_REVERSE
+namespace Facebook.Yoga
+{
+    public enum YogaPositionType
+    {
+        Relative,
+        Absolute,
+    }
 }

csharp/Facebook.Yoga/YogaPrintOptions.cs

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaPrintOptions
+    {
+        Layout = 1,
+        Style = 2,
+        Children = 4,
+    }
+}

csharp/Facebook.Yoga/YogaSize.cs

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using System.Runtime.InteropServices;
+
+namespace Facebook.Yoga
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct YogaSize
+    {
+        public float width;
+        public float height;
+    }
+}

csharp/Facebook.Yoga/YogaWrap.cs

@@ -1,14 +1,17 @@
 /**
- * Copyright (c) 2014, Facebook, Inc.
+ * Copyright (c) 2014-present, Facebook, Inc.
  * All rights reserved.
  *
  * This source code is licensed under the BSD-style license found in the
  * LICENSE file in the root directory of this source tree. An additional grant
  * of patent rights can be found in the PATENTS file in the same directory.
  */
-package com.facebook.csslayout;
 
-public enum CSSPositionType {
-  RELATIVE,
-  ABSOLUTE,
+namespace Facebook.Yoga
+{
+    public enum YogaWrap
+    {
+        NoWrap,
+        Wrap,
+    }
 }

csharp/Facebook.Yoga/project.json

@@ -0,0 +1,14 @@
+{
+  "language": "en",
+  "version": "3.0.0-*",
+
+  "dependencies": {
+    "NETStandard.Library": "1.6.0"
+  },
+
+  "frameworks": {
+    "netstandard1.6": {
+      "imports": "dnxcore50"
+    }
+  }
+}

csharp/Yoga/YGInterop.cpp

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include "YGInterop.h"
+
+static YGInteropLoggerFunc gManagedFunc;
+
+static int unmanagedLogger(YGLogLevel level, const char *format, va_list args) {
+  int result = 0;
+  if (gManagedFunc) {
+    char buffer[256];
+    result = vsnprintf(buffer, sizeof(buffer), format, args);
+    (*gManagedFunc)(level, buffer);
+  }
+  return result;
+}
+
+void YGInteropSetLogger(YGInteropLoggerFunc managedFunc) {
+  gManagedFunc = managedFunc;
+  YGSetLogger(&unmanagedLogger);
+}

csharp/Yoga/YGInterop.h

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <CSSLayout/Yoga.h>
+
+YG_EXTERN_C_BEGIN
+
+typedef void (*YGInteropLoggerFunc)(YGLogLevel level, const char *message);
+
+WIN_EXPORT void YGInteropSetLogger(YGInteropLoggerFunc managedFunc);
+
+YG_EXTERN_C_END

csharp/Yoga/Yoga.vcxproj

@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>Yoga</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.14393.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;YOGA_EXPORTS;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+      <AdditionalIncludeDirectories>$(ProjectDir)..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;YOGA_EXPORTS;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+      <AdditionalIncludeDirectories>$(ProjectDir)..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;YOGA_EXPORTS;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+      <AdditionalIncludeDirectories>$(ProjectDir)..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;YOGA_EXPORTS;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+      <AdditionalIncludeDirectories>$(ProjectDir)..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\CSSLayout\Yoga.h" />
+    <ClInclude Include="..\..\CSSLayout\YGMacros.h" />
+    <ClInclude Include="..\..\CSSLayout\YGNodeList.h" />
+    <ClInclude Include="YGInterop.h" />
+    <ClInclude Include="stdafx.h" />
+    <ClInclude Include="targetver.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\CSSLayout\Yoga.c" />
+    <ClCompile Include="..\..\CSSLayout\YGNodeList.c" />
+    <ClCompile Include="YGInterop.cpp" />
+    <ClCompile Include="dllmain.cpp">
+      <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</CompileAsManaged>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+      </PrecompiledHeader>
+      <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</CompileAsManaged>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+      </PrecompiledHeader>
+      <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</CompileAsManaged>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+      </PrecompiledHeader>
+      <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</CompileAsManaged>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+      </PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="stdafx.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

csharp/Yoga/Yoga.vcxproj.filters

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="stdafx.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="targetver.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\CSSLayout\Yoga.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\CSSLayout\YGMacros.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\CSSLayout\YGNodeList.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="YGInterop.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="stdafx.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="dllmain.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\CSSLayout\Yoga.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\CSSLayout\YGNodeList.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="YGInterop.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

csharp/Yoga/dllmain.cpp

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+// dllmain.cpp : Defines the entry point for the DLL application.
+#include "stdafx.h"
+
+BOOL APIENTRY DllMain( HMODULE hModule,
+                       DWORD  ul_reason_for_call,
+                       LPVOID lpReserved
+					 )
+{
+	switch (ul_reason_for_call)
+	{
+	case DLL_PROCESS_ATTACH:
+	case DLL_THREAD_ATTACH:
+	case DLL_THREAD_DETACH:
+	case DLL_PROCESS_DETACH:
+		break;
+	}
+	return TRUE;
+}

csharp/Yoga/stdafx.cpp

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+// stdafx.cpp : source file that includes just the standard includes
+// Yoga.pch will be the pre-compiled header
+// stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
+
+// TODO: reference any additional headers you need in STDAFX.H
+// and not in this file

csharp/Yoga/stdafx.h

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+#include "targetver.h"
+
+#define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
+// Windows Header Files:
+#include <windows.h>
+
+
+
+// TODO: reference additional headers your program requires here

csharp/Yoga/targetver.h

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+// Including SDKDDKVer.h defines the highest available Windows platform.
+
+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
+
+#include <SDKDDKVer.h>

csharp/tests/Facebook.Yoga/YGAbsolutePositionTest.cs

@@ -0,0 +1,314 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGAbsolutePositionTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGAbsolutePositionTest
+    {
+        [Test]
+        public void Test_absolute_layout_width_height_start_top()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.PositionType = YogaPositionType.Absolute;
+            root_child0.SetPosition(YogaEdge.Start, 10f);
+            root_child0.SetPosition(YogaEdge.Top, 10f);
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_absolute_layout_width_height_end_bottom()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.PositionType = YogaPositionType.Absolute;
+            root_child0.SetPosition(YogaEdge.End, 10f);
+            root_child0.SetPosition(YogaEdge.Bottom, 10f);
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child0.LayoutX);
+            Assert.AreEqual(80f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(80f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_absolute_layout_start_top_end_bottom()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.PositionType = YogaPositionType.Absolute;
+            root_child0.SetPosition(YogaEdge.Start, 10f);
+            root_child0.SetPosition(YogaEdge.Top, 10f);
+            root_child0.SetPosition(YogaEdge.End, 10f);
+            root_child0.SetPosition(YogaEdge.Bottom, 10f);
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(80f, root_child0.LayoutWidth);
+            Assert.AreEqual(80f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(80f, root_child0.LayoutWidth);
+            Assert.AreEqual(80f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_absolute_layout_width_height_start_top_end_bottom()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.PositionType = YogaPositionType.Absolute;
+            root_child0.SetPosition(YogaEdge.Start, 10f);
+            root_child0.SetPosition(YogaEdge.Top, 10f);
+            root_child0.SetPosition(YogaEdge.End, 10f);
+            root_child0.SetPosition(YogaEdge.Bottom, 10f);
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_do_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hidden_parent()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Overflow = YogaOverflow.Hidden;
+            root.Width = 50f;
+            root.Height = 50f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.PositionType = YogaPositionType.Absolute;
+            root_child0.SetPosition(YogaEdge.Start, 0f);
+            root_child0.SetPosition(YogaEdge.Top, 0f);
+            root.Insert(0, root_child0);
+
+            YogaNode root_child0_child0 = new YogaNode();
+            root_child0_child0.Width = 100f;
+            root_child0_child0.Height = 100f;
+            root_child0.Insert(0, root_child0_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(50f, root.LayoutWidth);
+            Assert.AreEqual(50f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(50f, root.LayoutWidth);
+            Assert.AreEqual(50f, root.LayoutHeight);
+
+            Assert.AreEqual(-50f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_absolute_layout_within_border()
+        {
+            YogaNode root = new YogaNode();
+            root.SetMargin(YogaEdge.Left, 10f);
+            root.SetMargin(YogaEdge.Top, 10f);
+            root.SetMargin(YogaEdge.Right, 10f);
+            root.SetMargin(YogaEdge.Bottom, 10f);
+            root.SetPadding(YogaEdge.Left, 10f);
+            root.SetPadding(YogaEdge.Top, 10f);
+            root.SetPadding(YogaEdge.Right, 10f);
+            root.SetPadding(YogaEdge.Bottom, 10f);
+            root.SetBorder(YogaEdge.Left, 10f);
+            root.SetBorder(YogaEdge.Top, 10f);
+            root.SetBorder(YogaEdge.Right, 10f);
+            root.SetBorder(YogaEdge.Bottom, 10f);
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.PositionType = YogaPositionType.Absolute;
+            root_child0.SetPosition(YogaEdge.Left, 0f);
+            root_child0.SetPosition(YogaEdge.Top, 0f);
+            root_child0.Width = 50f;
+            root_child0.Height = 50f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.PositionType = YogaPositionType.Absolute;
+            root_child1.SetPosition(YogaEdge.Right, 0f);
+            root_child1.SetPosition(YogaEdge.Bottom, 0f);
+            root_child1.Width = 50f;
+            root_child1.Height = 50f;
+            root.Insert(1, root_child1);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(10f, root.LayoutX);
+            Assert.AreEqual(10f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(40f, root_child1.LayoutX);
+            Assert.AreEqual(40f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(50f, root_child1.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(10f, root.LayoutX);
+            Assert.AreEqual(10f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(40f, root_child1.LayoutX);
+            Assert.AreEqual(40f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(50f, root_child1.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGAlignContentTest.cs

@@ -0,0 +1,415 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGAlignContentTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGAlignContentTest
+    {
+        [Test]
+        public void Test_align_content_flex_start()
+        {
+            YogaNode root = new YogaNode();
+            root.Wrap = YogaWrap.Wrap;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 50f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 50f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 50f;
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+
+            YogaNode root_child3 = new YogaNode();
+            root_child3.Width = 50f;
+            root_child3.Height = 10f;
+            root.Insert(3, root_child3);
+
+            YogaNode root_child4 = new YogaNode();
+            root_child4.Width = 50f;
+            root_child4.Height = 10f;
+            root.Insert(4, root_child4);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(20f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(50f, root_child3.LayoutWidth);
+            Assert.AreEqual(10f, root_child3.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child4.LayoutX);
+            Assert.AreEqual(40f, root_child4.LayoutY);
+            Assert.AreEqual(50f, root_child4.LayoutWidth);
+            Assert.AreEqual(10f, root_child4.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child2.LayoutX);
+            Assert.AreEqual(20f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(50f, root_child3.LayoutWidth);
+            Assert.AreEqual(10f, root_child3.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child4.LayoutX);
+            Assert.AreEqual(40f, root_child4.LayoutY);
+            Assert.AreEqual(50f, root_child4.LayoutWidth);
+            Assert.AreEqual(10f, root_child4.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_align_content_flex_end()
+        {
+            YogaNode root = new YogaNode();
+            root.AlignContent = YogaAlign.FlexEnd;
+            root.Wrap = YogaWrap.Wrap;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 50f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 50f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 50f;
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+
+            YogaNode root_child3 = new YogaNode();
+            root_child3.Width = 50f;
+            root_child3.Height = 10f;
+            root.Insert(3, root_child3);
+
+            YogaNode root_child4 = new YogaNode();
+            root_child4.Width = 50f;
+            root_child4.Height = 10f;
+            root.Insert(4, root_child4);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(20f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(50f, root_child3.LayoutWidth);
+            Assert.AreEqual(10f, root_child3.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child4.LayoutX);
+            Assert.AreEqual(40f, root_child4.LayoutY);
+            Assert.AreEqual(50f, root_child4.LayoutWidth);
+            Assert.AreEqual(10f, root_child4.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child2.LayoutX);
+            Assert.AreEqual(20f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(50f, root_child3.LayoutWidth);
+            Assert.AreEqual(10f, root_child3.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child4.LayoutX);
+            Assert.AreEqual(40f, root_child4.LayoutY);
+            Assert.AreEqual(50f, root_child4.LayoutWidth);
+            Assert.AreEqual(10f, root_child4.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_align_content_center()
+        {
+            YogaNode root = new YogaNode();
+            root.AlignContent = YogaAlign.Center;
+            root.Wrap = YogaWrap.Wrap;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 50f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 50f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 50f;
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+
+            YogaNode root_child3 = new YogaNode();
+            root_child3.Width = 50f;
+            root_child3.Height = 10f;
+            root.Insert(3, root_child3);
+
+            YogaNode root_child4 = new YogaNode();
+            root_child4.Width = 50f;
+            root_child4.Height = 10f;
+            root.Insert(4, root_child4);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(20f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(50f, root_child3.LayoutWidth);
+            Assert.AreEqual(10f, root_child3.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child4.LayoutX);
+            Assert.AreEqual(40f, root_child4.LayoutY);
+            Assert.AreEqual(50f, root_child4.LayoutWidth);
+            Assert.AreEqual(10f, root_child4.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child2.LayoutX);
+            Assert.AreEqual(20f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(50f, root_child3.LayoutWidth);
+            Assert.AreEqual(10f, root_child3.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child4.LayoutX);
+            Assert.AreEqual(40f, root_child4.LayoutY);
+            Assert.AreEqual(50f, root_child4.LayoutWidth);
+            Assert.AreEqual(10f, root_child4.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_align_content_stretch()
+        {
+            YogaNode root = new YogaNode();
+            root.AlignContent = YogaAlign.Stretch;
+            root.Wrap = YogaWrap.Wrap;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 50f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 50f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 50f;
+            root.Insert(2, root_child2);
+
+            YogaNode root_child3 = new YogaNode();
+            root_child3.Width = 50f;
+            root.Insert(3, root_child3);
+
+            YogaNode root_child4 = new YogaNode();
+            root_child4.Width = 50f;
+            root.Insert(4, root_child4);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(0f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(0f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(0f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child3.LayoutX);
+            Assert.AreEqual(0f, root_child3.LayoutY);
+            Assert.AreEqual(50f, root_child3.LayoutWidth);
+            Assert.AreEqual(0f, root_child3.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child4.LayoutX);
+            Assert.AreEqual(0f, root_child4.LayoutY);
+            Assert.AreEqual(50f, root_child4.LayoutWidth);
+            Assert.AreEqual(0f, root_child4.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(0f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(0f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(0f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child3.LayoutX);
+            Assert.AreEqual(0f, root_child3.LayoutY);
+            Assert.AreEqual(50f, root_child3.LayoutWidth);
+            Assert.AreEqual(0f, root_child3.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child4.LayoutX);
+            Assert.AreEqual(0f, root_child4.LayoutY);
+            Assert.AreEqual(50f, root_child4.LayoutWidth);
+            Assert.AreEqual(0f, root_child4.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGAlignItemsTest.cs

@@ -0,0 +1,175 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGAlignItemsTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGAlignItemsTest
+    {
+        [Test]
+        public void Test_align_items_stretch()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_align_items_center()
+        {
+            YogaNode root = new YogaNode();
+            root.AlignItems = YogaAlign.Center;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(45f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(45f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_align_items_flex_start()
+        {
+            YogaNode root = new YogaNode();
+            root.AlignItems = YogaAlign.FlexStart;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(90f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_align_items_flex_end()
+        {
+            YogaNode root = new YogaNode();
+            root.AlignItems = YogaAlign.FlexEnd;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(90f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGAlignSelfTest.cs

@@ -0,0 +1,178 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGAlignSelfTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGAlignSelfTest
+    {
+        [Test]
+        public void Test_align_self_center()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.AlignSelf = YogaAlign.Center;
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(45f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(45f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_align_self_flex_end()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.AlignSelf = YogaAlign.FlexEnd;
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(90f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_align_self_flex_start()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.AlignSelf = YogaAlign.FlexStart;
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(90f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_align_self_flex_end_override_flex_start()
+        {
+            YogaNode root = new YogaNode();
+            root.AlignItems = YogaAlign.FlexStart;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.AlignSelf = YogaAlign.FlexEnd;
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(90f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGBorderTest.cs

@@ -0,0 +1,212 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGBorderTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGBorderTest
+    {
+        [Test]
+        public void Test_border_no_size()
+        {
+            YogaNode root = new YogaNode();
+            root.SetBorder(YogaEdge.Left, 10f);
+            root.SetBorder(YogaEdge.Top, 10f);
+            root.SetBorder(YogaEdge.Right, 10f);
+            root.SetBorder(YogaEdge.Bottom, 10f);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(20f, root.LayoutWidth);
+            Assert.AreEqual(20f, root.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(20f, root.LayoutWidth);
+            Assert.AreEqual(20f, root.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_border_container_match_child()
+        {
+            YogaNode root = new YogaNode();
+            root.SetBorder(YogaEdge.Left, 10f);
+            root.SetBorder(YogaEdge.Top, 10f);
+            root.SetBorder(YogaEdge.Right, 10f);
+            root.SetBorder(YogaEdge.Bottom, 10f);
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(30f, root.LayoutWidth);
+            Assert.AreEqual(30f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(30f, root.LayoutWidth);
+            Assert.AreEqual(30f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_border_flex_child()
+        {
+            YogaNode root = new YogaNode();
+            root.SetBorder(YogaEdge.Left, 10f);
+            root.SetBorder(YogaEdge.Top, 10f);
+            root.SetBorder(YogaEdge.Right, 10f);
+            root.SetBorder(YogaEdge.Bottom, 10f);
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(80f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(80f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_border_stretch_child()
+        {
+            YogaNode root = new YogaNode();
+            root.SetBorder(YogaEdge.Left, 10f);
+            root.SetBorder(YogaEdge.Top, 10f);
+            root.SetBorder(YogaEdge.Right, 10f);
+            root.SetBorder(YogaEdge.Bottom, 10f);
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(80f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(80f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_border_center_child()
+        {
+            YogaNode root = new YogaNode();
+            root.JustifyContent = YogaJustify.Center;
+            root.AlignItems = YogaAlign.Center;
+            root.SetBorder(YogaEdge.Start, 10f);
+            root.SetBorder(YogaEdge.End, 20f);
+            root.SetBorder(YogaEdge.Bottom, 20f);
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(40f, root_child0.LayoutX);
+            Assert.AreEqual(35f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child0.LayoutX);
+            Assert.AreEqual(35f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGFlexDirectionTest.cs

@@ -0,0 +1,413 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGFlexDirectionTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGFlexDirectionTest
+    {
+        [Test]
+        public void Test_flex_direction_column_no_height()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(30f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(20f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(30f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(20f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_direction_row_no_width()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(30f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(20f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(30f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(20f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_direction_column()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(20f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(20f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_direction_row()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(20f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(90f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(70f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_direction_column_reverse()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.ColumnReverse;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(90f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(80f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(70f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(90f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(80f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(70f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_direction_row_reverse()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.RowReverse;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(90f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(70f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(20f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGFlexTest.cs

@@ -0,0 +1,419 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGFlexTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGFlexTest
+    {
+        [Test]
+        public void Test_flex_basis_flex_grow_column()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.FlexBasis = 50f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root.Insert(1, root_child1);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(75f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(75f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(25f, root_child1.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(75f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(75f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(25f, root_child1.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_basis_flex_grow_row()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.FlexBasis = 50f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root.Insert(1, root_child1);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(75f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(75f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(25f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(25f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(75f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(25f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_basis_flex_shrink_column()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexShrink = 1f;
+            root_child0.FlexBasis = 100f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexBasis = 50f;
+            root.Insert(1, root_child1);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(50f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(50f, root_child1.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(50f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(50f, root_child1.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_basis_flex_shrink_row()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexShrink = 1f;
+            root_child0.FlexBasis = 100f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexBasis = 50f;
+            root.Insert(1, root_child1);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_shrink_to_zero()
+        {
+            YogaNode root = new YogaNode();
+            root.Height = 75f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 50f;
+            root_child0.Height = 50f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexShrink = 1f;
+            root_child1.Width = 50f;
+            root_child1.Height = 50f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 50f;
+            root_child2.Height = 50f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(50f, root.LayoutWidth);
+            Assert.AreEqual(75f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(50f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(0f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(50f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(50f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(50f, root.LayoutWidth);
+            Assert.AreEqual(75f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(50f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(0f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(50f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(50f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_basis_overrides_main_size()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.FlexBasis = 50f;
+            root_child0.Height = 20f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexGrow = 1f;
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(60f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(60f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(20f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(80f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(20f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(60f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(60f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(20f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(80f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(20f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_grow_shrink_at_most()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root.Insert(0, root_child0);
+
+            YogaNode root_child0_child0 = new YogaNode();
+            root_child0_child0.FlexGrow = 1f;
+            root_child0_child0.FlexShrink = 1f;
+            root_child0.Insert(0, root_child0_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(0f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0_child0.LayoutWidth);
+            Assert.AreEqual(0f, root_child0_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(0f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0_child0.LayoutWidth);
+            Assert.AreEqual(0f, root_child0_child0.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGFlexWrapTest.cs

@@ -0,0 +1,358 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGFlexWrapTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGFlexWrapTest
+    {
+        [Test]
+        public void Test_wrap_column()
+        {
+            YogaNode root = new YogaNode();
+            root.Wrap = YogaWrap.Wrap;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 30f;
+            root_child0.Height = 30f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 30f;
+            root_child1.Height = 30f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 30f;
+            root_child2.Height = 30f;
+            root.Insert(2, root_child2);
+
+            YogaNode root_child3 = new YogaNode();
+            root_child3.Width = 30f;
+            root_child3.Height = 30f;
+            root.Insert(3, root_child3);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(60f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(30f, root_child0.LayoutWidth);
+            Assert.AreEqual(30f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(30f, root_child1.LayoutY);
+            Assert.AreEqual(30f, root_child1.LayoutWidth);
+            Assert.AreEqual(30f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(60f, root_child2.LayoutY);
+            Assert.AreEqual(30f, root_child2.LayoutWidth);
+            Assert.AreEqual(30f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(30f, root_child3.LayoutX);
+            Assert.AreEqual(0f, root_child3.LayoutY);
+            Assert.AreEqual(30f, root_child3.LayoutWidth);
+            Assert.AreEqual(30f, root_child3.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(60f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(30f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(30f, root_child0.LayoutWidth);
+            Assert.AreEqual(30f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(30f, root_child1.LayoutX);
+            Assert.AreEqual(30f, root_child1.LayoutY);
+            Assert.AreEqual(30f, root_child1.LayoutWidth);
+            Assert.AreEqual(30f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(30f, root_child2.LayoutX);
+            Assert.AreEqual(60f, root_child2.LayoutY);
+            Assert.AreEqual(30f, root_child2.LayoutWidth);
+            Assert.AreEqual(30f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child3.LayoutX);
+            Assert.AreEqual(0f, root_child3.LayoutY);
+            Assert.AreEqual(30f, root_child3.LayoutWidth);
+            Assert.AreEqual(30f, root_child3.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_wrap_row()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Wrap = YogaWrap.Wrap;
+            root.Width = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 30f;
+            root_child0.Height = 30f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 30f;
+            root_child1.Height = 30f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 30f;
+            root_child2.Height = 30f;
+            root.Insert(2, root_child2);
+
+            YogaNode root_child3 = new YogaNode();
+            root_child3.Width = 30f;
+            root_child3.Height = 30f;
+            root.Insert(3, root_child3);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(60f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(30f, root_child0.LayoutWidth);
+            Assert.AreEqual(30f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(30f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(30f, root_child1.LayoutWidth);
+            Assert.AreEqual(30f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(60f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(30f, root_child2.LayoutWidth);
+            Assert.AreEqual(30f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(30f, root_child3.LayoutWidth);
+            Assert.AreEqual(30f, root_child3.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(60f, root.LayoutHeight);
+
+            Assert.AreEqual(70f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(30f, root_child0.LayoutWidth);
+            Assert.AreEqual(30f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(40f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(30f, root_child1.LayoutWidth);
+            Assert.AreEqual(30f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(30f, root_child2.LayoutWidth);
+            Assert.AreEqual(30f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(70f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(30f, root_child3.LayoutWidth);
+            Assert.AreEqual(30f, root_child3.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_wrap_row_align_items_flex_end()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.AlignItems = YogaAlign.FlexEnd;
+            root.Wrap = YogaWrap.Wrap;
+            root.Width = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 30f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 30f;
+            root_child1.Height = 20f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 30f;
+            root_child2.Height = 30f;
+            root.Insert(2, root_child2);
+
+            YogaNode root_child3 = new YogaNode();
+            root_child3.Width = 30f;
+            root_child3.Height = 30f;
+            root.Insert(3, root_child3);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(60f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(20f, root_child0.LayoutY);
+            Assert.AreEqual(30f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(30f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(30f, root_child1.LayoutWidth);
+            Assert.AreEqual(20f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(60f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(30f, root_child2.LayoutWidth);
+            Assert.AreEqual(30f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(30f, root_child3.LayoutWidth);
+            Assert.AreEqual(30f, root_child3.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(60f, root.LayoutHeight);
+
+            Assert.AreEqual(70f, root_child0.LayoutX);
+            Assert.AreEqual(20f, root_child0.LayoutY);
+            Assert.AreEqual(30f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(40f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(30f, root_child1.LayoutWidth);
+            Assert.AreEqual(20f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(30f, root_child2.LayoutWidth);
+            Assert.AreEqual(30f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(70f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(30f, root_child3.LayoutWidth);
+            Assert.AreEqual(30f, root_child3.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_wrap_row_align_items_center()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.AlignItems = YogaAlign.Center;
+            root.Wrap = YogaWrap.Wrap;
+            root.Width = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 30f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 30f;
+            root_child1.Height = 20f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 30f;
+            root_child2.Height = 30f;
+            root.Insert(2, root_child2);
+
+            YogaNode root_child3 = new YogaNode();
+            root_child3.Width = 30f;
+            root_child3.Height = 30f;
+            root.Insert(3, root_child3);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(60f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(30f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(30f, root_child1.LayoutX);
+            Assert.AreEqual(5f, root_child1.LayoutY);
+            Assert.AreEqual(30f, root_child1.LayoutWidth);
+            Assert.AreEqual(20f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(60f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(30f, root_child2.LayoutWidth);
+            Assert.AreEqual(30f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(30f, root_child3.LayoutWidth);
+            Assert.AreEqual(30f, root_child3.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(60f, root.LayoutHeight);
+
+            Assert.AreEqual(70f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(30f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(40f, root_child1.LayoutX);
+            Assert.AreEqual(5f, root_child1.LayoutY);
+            Assert.AreEqual(30f, root_child1.LayoutWidth);
+            Assert.AreEqual(20f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(30f, root_child2.LayoutWidth);
+            Assert.AreEqual(30f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(70f, root_child3.LayoutX);
+            Assert.AreEqual(30f, root_child3.LayoutY);
+            Assert.AreEqual(30f, root_child3.LayoutWidth);
+            Assert.AreEqual(30f, root_child3.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGJustifyContentTest.cs

@@ -0,0 +1,683 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGJustifyContentTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGJustifyContentTest
+    {
+        [Test]
+        public void Test_justify_content_row_flex_start()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 102f;
+            root.Height = 102f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(102f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(102f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(20f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(102f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(92f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(102f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(82f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(102f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(72f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(102f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_row_flex_end()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.JustifyContent = YogaJustify.FlexEnd;
+            root.Width = 102f;
+            root.Height = 102f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(72f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(102f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(82f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(102f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(92f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(102f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(20f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(102f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(102f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(102f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_row_center()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.JustifyContent = YogaJustify.Center;
+            root.Width = 102f;
+            root.Height = 102f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(36f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(102f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(46f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(102f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(56f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(102f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(56f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(102f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(46f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(102f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(36f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(102f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_row_space_between()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.JustifyContent = YogaJustify.SpaceBetween;
+            root.Width = 102f;
+            root.Height = 102f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(102f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(46f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(102f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(92f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(102f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(92f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(102f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(46f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(102f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(102f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_row_space_around()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.JustifyContent = YogaJustify.SpaceAround;
+            root.Width = 102f;
+            root.Height = 102f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(12f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(102f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(46f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(102f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(102f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(102f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(46f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(10f, root_child1.LayoutWidth);
+            Assert.AreEqual(102f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(12f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(10f, root_child2.LayoutWidth);
+            Assert.AreEqual(102f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_column_flex_start()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 102f;
+            root.Height = 102f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(102f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(102f, root_child1.LayoutWidth);
+            Assert.AreEqual(0f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(10f, root_child2.LayoutY);
+            Assert.AreEqual(102f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(102f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(10f, root_child1.LayoutY);
+            Assert.AreEqual(102f, root_child1.LayoutWidth);
+            Assert.AreEqual(0f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(10f, root_child2.LayoutY);
+            Assert.AreEqual(102f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_column_flex_end()
+        {
+            YogaNode root = new YogaNode();
+            root.JustifyContent = YogaJustify.FlexEnd;
+            root.Width = 102f;
+            root.Height = 102f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(72f, root_child0.LayoutY);
+            Assert.AreEqual(102f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(82f, root_child1.LayoutY);
+            Assert.AreEqual(102f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(92f, root_child2.LayoutY);
+            Assert.AreEqual(102f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(72f, root_child0.LayoutY);
+            Assert.AreEqual(102f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(82f, root_child1.LayoutY);
+            Assert.AreEqual(102f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(92f, root_child2.LayoutY);
+            Assert.AreEqual(102f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_column_center()
+        {
+            YogaNode root = new YogaNode();
+            root.JustifyContent = YogaJustify.Center;
+            root.Width = 102f;
+            root.Height = 102f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(36f, root_child0.LayoutY);
+            Assert.AreEqual(102f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(46f, root_child1.LayoutY);
+            Assert.AreEqual(102f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(56f, root_child2.LayoutY);
+            Assert.AreEqual(102f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(36f, root_child0.LayoutY);
+            Assert.AreEqual(102f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(46f, root_child1.LayoutY);
+            Assert.AreEqual(102f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(56f, root_child2.LayoutY);
+            Assert.AreEqual(102f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_column_space_between()
+        {
+            YogaNode root = new YogaNode();
+            root.JustifyContent = YogaJustify.SpaceBetween;
+            root.Width = 102f;
+            root.Height = 102f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(102f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(46f, root_child1.LayoutY);
+            Assert.AreEqual(102f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(92f, root_child2.LayoutY);
+            Assert.AreEqual(102f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(102f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(46f, root_child1.LayoutY);
+            Assert.AreEqual(102f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(92f, root_child2.LayoutY);
+            Assert.AreEqual(102f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_column_space_around()
+        {
+            YogaNode root = new YogaNode();
+            root.JustifyContent = YogaJustify.SpaceAround;
+            root.Width = 102f;
+            root.Height = 102f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(12f, root_child0.LayoutY);
+            Assert.AreEqual(102f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(46f, root_child1.LayoutY);
+            Assert.AreEqual(102f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(80f, root_child2.LayoutY);
+            Assert.AreEqual(102f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(102f, root.LayoutWidth);
+            Assert.AreEqual(102f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(12f, root_child0.LayoutY);
+            Assert.AreEqual(102f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(46f, root_child1.LayoutY);
+            Assert.AreEqual(102f, root_child1.LayoutWidth);
+            Assert.AreEqual(10f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(80f, root_child2.LayoutY);
+            Assert.AreEqual(102f, root_child2.LayoutWidth);
+            Assert.AreEqual(10f, root_child2.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGMarginTest.cs

@@ -0,0 +1,434 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGMarginTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGMarginTest
+    {
+        [Test]
+        public void Test_margin_start()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.SetMargin(YogaEdge.Start, 10f);
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_margin_top()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.SetMargin(YogaEdge.Top, 10f);
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_margin_end()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.JustifyContent = YogaJustify.FlexEnd;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.SetMargin(YogaEdge.End, 10f);
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_margin_bottom()
+        {
+            YogaNode root = new YogaNode();
+            root.JustifyContent = YogaJustify.FlexEnd;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.SetMargin(YogaEdge.Bottom, 10f);
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(80f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(80f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_margin_and_flex_row()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.SetMargin(YogaEdge.Start, 10f);
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(90f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(90f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_margin_and_flex_column()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.SetMargin(YogaEdge.Top, 10f);
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(90f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(90f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_margin_and_stretch_row()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.SetMargin(YogaEdge.Top, 10f);
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(90f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(90f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_margin_and_stretch_column()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.SetMargin(YogaEdge.Start, 10f);
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(90f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(90f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_margin_with_sibling_row()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root.Insert(1, root_child1);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_margin_with_sibling_column()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root.Insert(1, root_child1);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(50f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(50f, root_child1.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(50f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(50f, root_child1.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGMinMaxDimensionTest.cs

@@ -0,0 +1,458 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGMinMaxDimensionTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGMinMaxDimensionTest
+    {
+        [Test]
+        public void Test_max_width()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.MaxWidth = 50f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_max_height()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root_child0.MaxHeight = 50f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(90f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_min_height()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.MinHeight = 60f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root.Insert(1, root_child1);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(80f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(80f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(20f, root_child1.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(80f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(80f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(20f, root_child1.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_min_width()
+        {
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.MinWidth = 60f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root.Insert(1, root_child1);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(80f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(20f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(20f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(80f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(20f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_min_max()
+        {
+            YogaNode root = new YogaNode();
+            root.JustifyContent = YogaJustify.Center;
+            root.Width = 100f;
+            root.MinHeight = 100f;
+            root.MaxHeight = 200f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 60f;
+            root_child0.Height = 60f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(20f, root_child0.LayoutY);
+            Assert.AreEqual(60f, root_child0.LayoutWidth);
+            Assert.AreEqual(60f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(40f, root_child0.LayoutX);
+            Assert.AreEqual(20f, root_child0.LayoutY);
+            Assert.AreEqual(60f, root_child0.LayoutWidth);
+            Assert.AreEqual(60f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_align_items_min_max()
+        {
+            YogaNode root = new YogaNode();
+            root.AlignItems = YogaAlign.Center;
+            root.MinWidth = 100f;
+            root.MaxWidth = 200f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 60f;
+            root_child0.Height = 60f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(20f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(60f, root_child0.LayoutWidth);
+            Assert.AreEqual(60f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(20f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(60f, root_child0.LayoutWidth);
+            Assert.AreEqual(60f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_justify_content_overflow_min_max()
+        {
+            YogaNode root = new YogaNode();
+            root.JustifyContent = YogaJustify.Center;
+            root.MinHeight = 100f;
+            root.MaxHeight = 110f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 50f;
+            root_child0.Height = 50f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.Width = 50f;
+            root_child1.Height = 50f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.Width = 50f;
+            root_child2.Height = 50f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(50f, root.LayoutWidth);
+            Assert.AreEqual(110f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(-20f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(30f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(50f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(80f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(50f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(50f, root.LayoutWidth);
+            Assert.AreEqual(110f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(-20f, root_child0.LayoutY);
+            Assert.AreEqual(50f, root_child0.LayoutWidth);
+            Assert.AreEqual(50f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(30f, root_child1.LayoutY);
+            Assert.AreEqual(50f, root_child1.LayoutWidth);
+            Assert.AreEqual(50f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(80f, root_child2.LayoutY);
+            Assert.AreEqual(50f, root_child2.LayoutWidth);
+            Assert.AreEqual(50f, root_child2.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_grow_within_max_width()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 200f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexDirection = YogaFlexDirection.Row;
+            root_child0.MaxWidth = 100f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child0_child0 = new YogaNode();
+            root_child0_child0.FlexGrow = 1f;
+            root_child0_child0.Height = 20f;
+            root_child0.Insert(0, root_child0_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(200f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(20f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0_child0.LayoutWidth);
+            Assert.AreEqual(20f, root_child0_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(200f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(100f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(20f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0_child0.LayoutWidth);
+            Assert.AreEqual(20f, root_child0_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_flex_grow_within_constrained_max_width()
+        {
+            YogaNode root = new YogaNode();
+            root.Width = 200f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexDirection = YogaFlexDirection.Row;
+            root_child0.MaxWidth = 300f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child0_child0 = new YogaNode();
+            root_child0_child0.FlexGrow = 1f;
+            root_child0_child0.Height = 20f;
+            root_child0.Insert(0, root_child0_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(200f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(200f, root_child0.LayoutWidth);
+            Assert.AreEqual(20f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0_child0.LayoutY);
+            Assert.AreEqual(200f, root_child0_child0.LayoutWidth);
+            Assert.AreEqual(20f, root_child0_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(200f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(200f, root_child0.LayoutWidth);
+            Assert.AreEqual(20f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0_child0.LayoutY);
+            Assert.AreEqual(200f, root_child0_child0.LayoutWidth);
+            Assert.AreEqual(20f, root_child0_child0.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGPaddingTest.cs

@@ -0,0 +1,256 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGPaddingTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGPaddingTest
+    {
+        [Test]
+        public void Test_padding_no_size()
+        {
+            YogaNode root = new YogaNode();
+            root.SetPadding(YogaEdge.Left, 10f);
+            root.SetPadding(YogaEdge.Top, 10f);
+            root.SetPadding(YogaEdge.Right, 10f);
+            root.SetPadding(YogaEdge.Bottom, 10f);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(20f, root.LayoutWidth);
+            Assert.AreEqual(20f, root.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(20f, root.LayoutWidth);
+            Assert.AreEqual(20f, root.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_padding_container_match_child()
+        {
+            YogaNode root = new YogaNode();
+            root.SetPadding(YogaEdge.Left, 10f);
+            root.SetPadding(YogaEdge.Top, 10f);
+            root.SetPadding(YogaEdge.Right, 10f);
+            root.SetPadding(YogaEdge.Bottom, 10f);
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(30f, root.LayoutWidth);
+            Assert.AreEqual(30f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(30f, root.LayoutWidth);
+            Assert.AreEqual(30f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_padding_flex_child()
+        {
+            YogaNode root = new YogaNode();
+            root.SetPadding(YogaEdge.Left, 10f);
+            root.SetPadding(YogaEdge.Top, 10f);
+            root.SetPadding(YogaEdge.Right, 10f);
+            root.SetPadding(YogaEdge.Bottom, 10f);
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.Width = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(80f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(80f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(80f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_padding_stretch_child()
+        {
+            YogaNode root = new YogaNode();
+            root.SetPadding(YogaEdge.Left, 10f);
+            root.SetPadding(YogaEdge.Top, 10f);
+            root.SetPadding(YogaEdge.Right, 10f);
+            root.SetPadding(YogaEdge.Bottom, 10f);
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(80f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(10f, root_child0.LayoutX);
+            Assert.AreEqual(10f, root_child0.LayoutY);
+            Assert.AreEqual(80f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_padding_center_child()
+        {
+            YogaNode root = new YogaNode();
+            root.JustifyContent = YogaJustify.Center;
+            root.AlignItems = YogaAlign.Center;
+            root.SetPadding(YogaEdge.Start, 10f);
+            root.SetPadding(YogaEdge.End, 20f);
+            root.SetPadding(YogaEdge.Bottom, 20f);
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.Width = 10f;
+            root_child0.Height = 10f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(40f, root_child0.LayoutX);
+            Assert.AreEqual(35f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child0.LayoutX);
+            Assert.AreEqual(35f, root_child0.LayoutY);
+            Assert.AreEqual(10f, root_child0.LayoutWidth);
+            Assert.AreEqual(10f, root_child0.LayoutHeight);
+        }
+
+        [Test]
+        public void Test_child_with_padding_align_end()
+        {
+            YogaNode root = new YogaNode();
+            root.JustifyContent = YogaJustify.FlexEnd;
+            root.AlignItems = YogaAlign.FlexEnd;
+            root.Width = 200f;
+            root.Height = 200f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.SetPadding(YogaEdge.Left, 20f);
+            root_child0.SetPadding(YogaEdge.Top, 20f);
+            root_child0.SetPadding(YogaEdge.Right, 20f);
+            root_child0.SetPadding(YogaEdge.Bottom, 20f);
+            root_child0.Width = 100f;
+            root_child0.Height = 100f;
+            root.Insert(0, root_child0);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(200f, root.LayoutWidth);
+            Assert.AreEqual(200f, root.LayoutHeight);
+
+            Assert.AreEqual(100f, root_child0.LayoutX);
+            Assert.AreEqual(100f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(200f, root.LayoutWidth);
+            Assert.AreEqual(200f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(100f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YGRoundingTest.cs

@@ -0,0 +1,807 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+ // @Generated by gentest/gentest.rb from gentest/fixtures/YGRoundingTest.html
+
+using System;
+using NUnit.Framework;
+
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YGRoundingTest
+    {
+        [Test]
+        public void Test_rounding_flex_basis_flex_grow_row_width_of_100()
+        {
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, true);
+
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 100f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexGrow = 1f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(33f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(33f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(34f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(67f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(33f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(67f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(33f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(33f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(34f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(33f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, false);
+        }
+
+        [Test]
+        public void Test_rounding_flex_basis_flex_grow_row_prime_number_width()
+        {
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, true);
+
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 113f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexGrow = 1f;
+            root.Insert(2, root_child2);
+
+            YogaNode root_child3 = new YogaNode();
+            root_child3.FlexGrow = 1f;
+            root.Insert(3, root_child3);
+
+            YogaNode root_child4 = new YogaNode();
+            root_child4.FlexGrow = 1f;
+            root.Insert(4, root_child4);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(113f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(23f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(23f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(22f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(45f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(23f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(68f, root_child3.LayoutX);
+            Assert.AreEqual(0f, root_child3.LayoutY);
+            Assert.AreEqual(22f, root_child3.LayoutWidth);
+            Assert.AreEqual(100f, root_child3.LayoutHeight);
+
+            Assert.AreEqual(90f, root_child4.LayoutX);
+            Assert.AreEqual(0f, root_child4.LayoutY);
+            Assert.AreEqual(23f, root_child4.LayoutWidth);
+            Assert.AreEqual(100f, root_child4.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(113f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(90f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(23f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(68f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(22f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(45f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(23f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+
+            Assert.AreEqual(23f, root_child3.LayoutX);
+            Assert.AreEqual(0f, root_child3.LayoutY);
+            Assert.AreEqual(22f, root_child3.LayoutWidth);
+            Assert.AreEqual(100f, root_child3.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child4.LayoutX);
+            Assert.AreEqual(0f, root_child4.LayoutY);
+            Assert.AreEqual(23f, root_child4.LayoutWidth);
+            Assert.AreEqual(100f, root_child4.LayoutHeight);
+
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, false);
+        }
+
+        [Test]
+        public void Test_rounding_flex_basis_flex_shrink_row()
+        {
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, true);
+
+            YogaNode root = new YogaNode();
+            root.FlexDirection = YogaFlexDirection.Row;
+            root.Width = 101f;
+            root.Height = 100f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexShrink = 1f;
+            root_child0.FlexBasis = 100f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexBasis = 25f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexBasis = 25f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(101f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(51f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(51f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(25f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(76f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(25f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(101f, root.LayoutWidth);
+            Assert.AreEqual(100f, root.LayoutHeight);
+
+            Assert.AreEqual(50f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(51f, root_child0.LayoutWidth);
+            Assert.AreEqual(100f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(25f, root_child1.LayoutX);
+            Assert.AreEqual(0f, root_child1.LayoutY);
+            Assert.AreEqual(25f, root_child1.LayoutWidth);
+            Assert.AreEqual(100f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(0f, root_child2.LayoutY);
+            Assert.AreEqual(25f, root_child2.LayoutWidth);
+            Assert.AreEqual(100f, root_child2.LayoutHeight);
+
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, false);
+        }
+
+        [Test]
+        public void Test_rounding_flex_basis_overrides_main_size()
+        {
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, true);
+
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 113f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.FlexBasis = 50f;
+            root_child0.Height = 20f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexGrow = 1f;
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(113f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(64f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(64f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(25f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(113f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(64f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(64f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(25f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, false);
+        }
+
+        [Test]
+        public void Test_rounding_total_fractial()
+        {
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, true);
+
+            YogaNode root = new YogaNode();
+            root.Width = 87.4f;
+            root.Height = 113.4f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 0.7f;
+            root_child0.FlexBasis = 50.3f;
+            root_child0.Height = 20.3f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1.6f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexGrow = 1.1f;
+            root_child2.Height = 10.7f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(87f, root.LayoutWidth);
+            Assert.AreEqual(113f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(87f, root_child0.LayoutWidth);
+            Assert.AreEqual(59f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(59f, root_child1.LayoutY);
+            Assert.AreEqual(87f, root_child1.LayoutWidth);
+            Assert.AreEqual(30f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(87f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(87f, root.LayoutWidth);
+            Assert.AreEqual(113f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(87f, root_child0.LayoutWidth);
+            Assert.AreEqual(59f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(59f, root_child1.LayoutY);
+            Assert.AreEqual(87f, root_child1.LayoutWidth);
+            Assert.AreEqual(30f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(87f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, false);
+        }
+
+        [Test]
+        public void Test_rounding_total_fractial_nested()
+        {
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, true);
+
+            YogaNode root = new YogaNode();
+            root.Width = 87.4f;
+            root.Height = 113.4f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 0.7f;
+            root_child0.FlexBasis = 50.3f;
+            root_child0.Height = 20.3f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child0_child0 = new YogaNode();
+            root_child0_child0.FlexGrow = 1f;
+            root_child0_child0.FlexBasis = 0.3f;
+            root_child0_child0.SetPosition(YogaEdge.Bottom, 13.3f);
+            root_child0_child0.Height = 9.9f;
+            root_child0.Insert(0, root_child0_child0);
+
+            YogaNode root_child0_child1 = new YogaNode();
+            root_child0_child1.FlexGrow = 4f;
+            root_child0_child1.FlexBasis = 0.3f;
+            root_child0_child1.SetPosition(YogaEdge.Top, 13.3f);
+            root_child0_child1.Height = 1.1f;
+            root_child0.Insert(1, root_child0_child1);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1.6f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexGrow = 1.1f;
+            root_child2.Height = 10.7f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(87f, root.LayoutWidth);
+            Assert.AreEqual(113f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(87f, root_child0.LayoutWidth);
+            Assert.AreEqual(59f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child0.LayoutX);
+            Assert.AreEqual(-13f, root_child0_child0.LayoutY);
+            Assert.AreEqual(87f, root_child0_child0.LayoutWidth);
+            Assert.AreEqual(12f, root_child0_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child1.LayoutX);
+            Assert.AreEqual(25f, root_child0_child1.LayoutY);
+            Assert.AreEqual(87f, root_child0_child1.LayoutWidth);
+            Assert.AreEqual(47f, root_child0_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(59f, root_child1.LayoutY);
+            Assert.AreEqual(87f, root_child1.LayoutWidth);
+            Assert.AreEqual(30f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(87f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(87f, root.LayoutWidth);
+            Assert.AreEqual(113f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(87f, root_child0.LayoutWidth);
+            Assert.AreEqual(59f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child0.LayoutX);
+            Assert.AreEqual(-13f, root_child0_child0.LayoutY);
+            Assert.AreEqual(87f, root_child0_child0.LayoutWidth);
+            Assert.AreEqual(12f, root_child0_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0_child1.LayoutX);
+            Assert.AreEqual(25f, root_child0_child1.LayoutY);
+            Assert.AreEqual(87f, root_child0_child1.LayoutWidth);
+            Assert.AreEqual(47f, root_child0_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(59f, root_child1.LayoutY);
+            Assert.AreEqual(87f, root_child1.LayoutWidth);
+            Assert.AreEqual(30f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(87f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, false);
+        }
+
+        [Test]
+        public void Test_rounding_fractial_input_1()
+        {
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, true);
+
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 113.4f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.FlexBasis = 50f;
+            root_child0.Height = 20f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexGrow = 1f;
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(113f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(64f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(64f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(25f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(113f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(64f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(64f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(25f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, false);
+        }
+
+        [Test]
+        public void Test_rounding_fractial_input_2()
+        {
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, true);
+
+            YogaNode root = new YogaNode();
+            root.Width = 100f;
+            root.Height = 113.6f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.FlexBasis = 50f;
+            root_child0.Height = 20f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexGrow = 1f;
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(114f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(65f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(65f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(24f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(25f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(114f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(65f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(65f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(24f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(25f, root_child2.LayoutHeight);
+
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, false);
+        }
+
+        [Test]
+        public void Test_rounding_fractial_input_3()
+        {
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, true);
+
+            YogaNode root = new YogaNode();
+            root.SetPosition(YogaEdge.Top, 0.3f);
+            root.Width = 100f;
+            root.Height = 113.4f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.FlexBasis = 50f;
+            root_child0.Height = 20f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexGrow = 1f;
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(114f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(64f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(64f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(25f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(0f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(114f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(64f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(64f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(25f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, false);
+        }
+
+        [Test]
+        public void Test_rounding_fractial_input_4()
+        {
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, true);
+
+            YogaNode root = new YogaNode();
+            root.SetPosition(YogaEdge.Top, 0.7f);
+            root.Width = 100f;
+            root.Height = 113.4f;
+
+            YogaNode root_child0 = new YogaNode();
+            root_child0.FlexGrow = 1f;
+            root_child0.FlexBasis = 50f;
+            root_child0.Height = 20f;
+            root.Insert(0, root_child0);
+
+            YogaNode root_child1 = new YogaNode();
+            root_child1.FlexGrow = 1f;
+            root_child1.Height = 10f;
+            root.Insert(1, root_child1);
+
+            YogaNode root_child2 = new YogaNode();
+            root_child2.FlexGrow = 1f;
+            root_child2.Height = 10f;
+            root.Insert(2, root_child2);
+            root.StyleDirection = YogaDirection.LTR;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(1f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(113f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(64f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(64f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(25f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            root.StyleDirection = YogaDirection.RTL;
+            root.CalculateLayout();
+
+            Assert.AreEqual(0f, root.LayoutX);
+            Assert.AreEqual(1f, root.LayoutY);
+            Assert.AreEqual(100f, root.LayoutWidth);
+            Assert.AreEqual(113f, root.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child0.LayoutX);
+            Assert.AreEqual(0f, root_child0.LayoutY);
+            Assert.AreEqual(100f, root_child0.LayoutWidth);
+            Assert.AreEqual(64f, root_child0.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child1.LayoutX);
+            Assert.AreEqual(64f, root_child1.LayoutY);
+            Assert.AreEqual(100f, root_child1.LayoutWidth);
+            Assert.AreEqual(25f, root_child1.LayoutHeight);
+
+            Assert.AreEqual(0f, root_child2.LayoutX);
+            Assert.AreEqual(89f, root_child2.LayoutY);
+            Assert.AreEqual(100f, root_child2.LayoutWidth);
+            Assert.AreEqual(24f, root_child2.LayoutHeight);
+
+            YogaNode.SetExperimentalFeatureEnabled(YogaExperimentalFeature.Rounding, false);
+        }
+
+    }
+}

csharp/tests/Facebook.Yoga/YogaNodeCreateTest.cs

@@ -0,0 +1,143 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using NUnit.Framework;
+using System;
+
+/**
+ * Tests for {@link YogaNode}.
+ */
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YogaNodeCreateTest
+    {
+        [Test]
+        public void TestSimple()
+        {
+            YogaNode nodeDefault = new YogaNode();
+            YogaNode nodeCreated = YogaNode.Create(flexDirection: YogaFlexDirection.Row);
+            Assert.AreEqual(YogaFlexDirection.Row, nodeCreated.FlexDirection);
+            Assert.IsFalse(nodeDefault.IsDirty);
+            nodeDefault.CopyStyle(nodeCreated);
+            Assert.IsTrue(nodeDefault.IsDirty);
+        }
+
+        [Test]
+        public void TestSame()
+        {
+            YogaNode nodeDefault = new YogaNode();
+            YogaNode nodeCreated = YogaNode.Create();
+            Assert.IsFalse(nodeDefault.IsDirty);
+            nodeDefault.CopyStyle(nodeCreated);
+            Assert.IsFalse(nodeDefault.IsDirty);
+        }
+
+        [Test]
+        public void TestMultiple()
+        {
+            YogaNode node = YogaNode.Create(
+                positionType: YogaPositionType.Absolute,
+                wrap: YogaWrap.Wrap,
+                position: new Spacing(top:6, right:4),
+                margin: new Spacing(bottom:5, left:3));
+
+            Assert.AreEqual(YogaFlexDirection.Column, node.FlexDirection);
+            Assert.AreEqual(YogaPositionType.Absolute, node.PositionType);
+            Assert.AreEqual(YogaWrap.Wrap, node.Wrap);
+            Assert.AreEqual(6, node.GetPosition(YogaEdge.Top));
+            Assert.IsTrue(YogaConstants.IsUndefined(node.GetPosition(YogaEdge.Bottom)));
+            Assert.AreEqual(4, node.GetPosition(YogaEdge.Right));
+            Assert.IsTrue(YogaConstants.IsUndefined(node.GetPosition(YogaEdge.Left)));
+            Assert.AreEqual(0, node.GetMargin(YogaEdge.Top));
+            Assert.AreEqual(5, node.GetMargin(YogaEdge.Bottom));
+            Assert.AreEqual(3, node.GetMargin(YogaEdge.Left));
+            Assert.AreEqual(0, node.GetMargin(YogaEdge.Right));
+        }
+
+        [Test]
+        public void TestFull()
+        {
+            YogaNode node = YogaNode.Create(
+                styleDirection: YogaDirection.RTL,
+                flexDirection: YogaFlexDirection.RowReverse,
+
+                justifyContent: YogaJustify.SpaceAround,
+                alignContent: YogaAlign.Center,
+                alignItems: YogaAlign.FlexEnd,
+                alignSelf: YogaAlign.Stretch,
+
+                positionType: YogaPositionType.Absolute,
+                wrap: YogaWrap.Wrap,
+                overflow: YogaOverflow.Scroll,
+
+                flex: 1,
+                flexGrow: 2,
+                flexShrink: 3,
+                flexBasis: 4,
+
+                position: new Spacing(top: 5, bottom: 6, left: 7, right: 8),
+                margin: new Spacing(top: 9, bottom: 10, left: 11, right: 12),
+                padding: new Spacing(top: 13, bottom: 14, left: 15, right: 16),
+                border: new Spacing(top: 17, bottom: 18, left: 19, right: 20),
+
+                Width: 21,
+                Height: 22,
+                MinWidth: 23,
+                MinHeight: 24,
+                MaxWidth: 25,
+                MaxHeight: 26);
+
+            Assert.AreEqual(YogaDirection.RTL, node.StyleDirection);
+            Assert.AreEqual(YogaFlexDirection.RowReverse, node.FlexDirection);
+
+            Assert.AreEqual(YogaJustify.SpaceAround, node.JustifyContent);
+            Assert.AreEqual(YogaAlign.Center, node.AlignContent);
+            Assert.AreEqual(YogaAlign.FlexEnd, node.AlignItems);
+            Assert.AreEqual(YogaAlign.Stretch, node.AlignSelf);
+
+            Assert.AreEqual(YogaPositionType.Absolute, node.PositionType);
+            Assert.AreEqual(YogaWrap.Wrap, node.Wrap);
+            Assert.AreEqual(YogaOverflow.Scroll, node.Overflow);
+
+            Assert.AreEqual(2, node.FlexGrow);
+            Assert.AreEqual(3, node.FlexShrink);
+            Assert.AreEqual(4, node.FlexBasis);
+            node.FlexGrow = YogaConstants.Undefined;
+            Assert.AreEqual(1, node.FlexGrow);
+
+            Assert.AreEqual(5, node.GetPosition(YogaEdge.Top));
+            Assert.AreEqual(6, node.GetPosition(YogaEdge.Bottom));
+            Assert.AreEqual(7, node.GetPosition(YogaEdge.Left));
+            Assert.AreEqual(8, node.GetPosition(YogaEdge.Right));
+
+            Assert.AreEqual(9, node.GetMargin(YogaEdge.Top));
+            Assert.AreEqual(10, node.GetMargin(YogaEdge.Bottom));
+            Assert.AreEqual(11, node.GetMargin(YogaEdge.Left));
+            Assert.AreEqual(12, node.GetMargin(YogaEdge.Right));
+
+            Assert.AreEqual(13, node.GetPadding(YogaEdge.Top));
+            Assert.AreEqual(14, node.GetPadding(YogaEdge.Bottom));
+            Assert.AreEqual(15, node.GetPadding(YogaEdge.Left));
+            Assert.AreEqual(16, node.GetPadding(YogaEdge.Right));
+
+            Assert.AreEqual(17, node.GetBorder(YogaEdge.Top));
+            Assert.AreEqual(18, node.GetBorder(YogaEdge.Bottom));
+            Assert.AreEqual(19, node.GetBorder(YogaEdge.Left));
+            Assert.AreEqual(20, node.GetBorder(YogaEdge.Right));
+
+            Assert.AreEqual(21, node.Width);
+            Assert.AreEqual(22, node.Height);
+            Assert.AreEqual(23, node.MinWidth);
+            Assert.AreEqual(24, node.MinHeight);
+            Assert.AreEqual(25, node.MaxWidth);
+            Assert.AreEqual(26, node.MaxHeight);
+        }
+    }
+}

csharp/tests/Facebook.Yoga/YogaNodeTest.cs

@@ -0,0 +1,361 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+using NUnit.Framework;
+using System;
+
+/**
+ * Tests for {@link YogaNode}.
+ */
+namespace Facebook.Yoga
+{
+    [TestFixture]
+    public class YogaNodeTest
+    {
+        [Test]
+        public void TestAddChildGetParent()
+        {
+            YogaNode parent = new YogaNode();
+            YogaNode child = new YogaNode();
+
+            Assert.IsNull(child.Parent);
+            Assert.AreEqual(0, parent.Count);
+
+            parent.Insert(0, child);
+
+            Assert.AreEqual(1, parent.Count);
+            Assert.AreEqual(child, parent[0]);
+            Assert.AreEqual(parent, child.Parent);
+
+            parent.RemoveAt(0);
+
+            Assert.IsNull(child.Parent);
+            Assert.AreEqual(0, parent.Count);
+        }
+
+        [Test]
+        public void TestChildren()
+        {
+            YogaNode parent = new YogaNode();
+            foreach (YogaNode node in parent) {
+                Assert.Fail(node.ToString());
+            }
+
+            YogaNode child0 = new YogaNode();
+            Assert.AreEqual(-1, parent.IndexOf(child0));
+            parent.Insert(0, child0);
+            foreach (YogaNode node in parent) {
+                Assert.AreEqual(0, parent.IndexOf(node));
+            }
+
+            YogaNode child1 = new YogaNode();
+            parent.Insert(1, child1);
+            int index = 0;
+            foreach (YogaNode node in parent) {
+                Assert.AreEqual(index++, parent.IndexOf(node));
+            }
+
+            parent.RemoveAt(0);
+            Assert.AreEqual(-1, parent.IndexOf(child0));
+            Assert.AreEqual(0, parent.IndexOf(child1));
+
+            parent.Clear();
+            Assert.AreEqual(0, parent.Count);
+
+            parent.Clear();
+            Assert.AreEqual(0, parent.Count);
+        }
+
+        [Test]
+        [ExpectedException("System.NullReferenceException")]
+        public void TestRemoveAtFromEmpty()
+        {
+            YogaNode parent = new YogaNode();
+            parent.RemoveAt(0);
+        }
+
+        [Test]
+        [ExpectedException("System.ArgumentOutOfRangeException")]
+        public void TestRemoveAtOutOfRange()
+        {
+            YogaNode parent = new YogaNode();
+            YogaNode child = new YogaNode();
+            parent.Insert(0, child);
+            parent.RemoveAt(1);
+        }
+
+        [Test]
+        [ExpectedException("System.InvalidOperationException")]
+        public void TestCannotAddChildToMultipleParents()
+        {
+            YogaNode parent1 = new YogaNode();
+            YogaNode parent2 = new YogaNode();
+            YogaNode child = new YogaNode();
+
+            parent1.Insert(0, child);
+            parent2.Insert(0, child);
+        }
+
+        [Test]
+        public void TestReset()
+        {
+            int instanceCount = YogaNode.GetInstanceCount();
+            YogaNode node = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+            node.Reset();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+        }
+
+        [Test]
+        [ExpectedException("System.InvalidOperationException")]
+        public void TestResetParent()
+        {
+            YogaNode parent = new YogaNode();
+            YogaNode child = new YogaNode();
+            parent.Insert(0, child);
+            parent.Reset();
+        }
+
+        [Test]
+        [ExpectedException("System.InvalidOperationException")]
+        public void TestResetChild()
+        {
+            YogaNode parent = new YogaNode();
+            YogaNode child = new YogaNode();
+            parent.Insert(0, child);
+            child.Reset();
+        }
+
+        [Test]
+        public void TestClear()
+        {
+            int instanceCount = YogaNode.GetInstanceCount();
+            YogaNode parent = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+            YogaNode child = new YogaNode();
+            Assert.AreEqual(instanceCount + 2, YogaNode.GetInstanceCount());
+            parent.Insert(0, child);
+            Assert.AreEqual(1, parent.Count);
+            Assert.AreEqual(parent, child.Parent);
+            parent.Clear();
+            Assert.AreEqual(0, parent.Count);
+            Assert.IsNull(child.Parent);
+            Assert.AreEqual(instanceCount + 2, YogaNode.GetInstanceCount());
+        }
+
+        [Test]
+        public void TestMeasureFunc()
+        {
+            YogaNode node = new YogaNode();
+            node.SetMeasureFunction((_, width, widthMode, height, heightMode) => {
+                return MeasureOutput.Make(100, 150);
+            });
+            node.CalculateLayout();
+            Assert.AreEqual(100, node.LayoutWidth);
+            Assert.AreEqual(150, node.LayoutHeight);
+        }
+
+        [Test]
+        public void TestMeasureFuncWithFloat()
+        {
+            YogaNode node = new YogaNode();
+            node.SetMeasureFunction((_, width, widthMode, height, heightMode) => {
+                return MeasureOutput.Make(123.4f, 81.7f);
+            });
+            node.CalculateLayout();
+            Assert.AreEqual(123, node.LayoutWidth);
+            Assert.AreEqual(81, node.LayoutHeight);
+        }
+
+        [Test]
+        [ExpectedException("System.InvalidOperationException")]
+        public void TestChildWithMeasureFunc()
+        {
+            YogaNode node = new YogaNode();
+            node.SetMeasureFunction((_, width, widthMode, height, heightMode) => {
+                return MeasureOutput.Make(100, 150);
+            });
+            YogaNode child = new YogaNode();
+            node.Insert(0, child);
+        }
+
+        [Test]
+        [ExpectedException("System.InvalidOperationException")]
+        public void TestMeasureFuncWithChild()
+        {
+            YogaNode node = new YogaNode();
+            YogaNode child = new YogaNode();
+            node.Insert(0, child);
+            node.SetMeasureFunction((_, width, widthMode, height, heightMode) => {
+                return MeasureOutput.Make(100, 150);
+            });
+        }
+
+        [Test]
+        public void TestPrint()
+        {
+            YogaNode parent = new YogaNode();
+            parent.Width = 100;
+            parent.Height = 120;
+            YogaNode child0 = new YogaNode();
+            child0.Width = 30;
+            child0.Height = 40;
+            YogaNode child1 = new YogaNode();
+            child1.Width = 35;
+            child1.Height = 45;
+            parent.Insert(0, child0);
+            parent.Insert(0, child1);
+            parent.CalculateLayout();
+            Assert.AreEqual(parent.Print(), "{layout: {width: 100, height: 120, top: 0, left: 0}, flexDirection: 'column', alignItems: 'stretch', flexGrow: 0, flexShrink: 0, overflow: 'visible', width: 100, height: 120, children: [\n  {layout: {width: 35, height: 45, top: 0, left: 0}, flexDirection: 'column', alignItems: 'stretch', flexGrow: 0, flexShrink: 0, overflow: 'visible', width: 35, height: 45, },\n  {layout: {width: 30, height: 40, top: 45, left: 0}, flexDirection: 'column', alignItems: 'stretch', flexGrow: 0, flexShrink: 0, overflow: 'visible', width: 30, height: 40, },\n]},\n");
+        }
+
+        [Test]
+        public void TestCopyStyle()
+        {
+            YogaNode node0 = new YogaNode();
+            Assert.IsTrue(YogaConstants.IsUndefined(node0.MaxHeight));
+
+            YogaNode node1 = new YogaNode();
+            node1.MaxHeight = 100;
+
+            node0.CopyStyle(node1);
+            Assert.AreEqual(100, node0.MaxHeight);
+        }
+
+#if !UNITY_EDITOR
+        private void ForceGC()
+        {
+            GC.Collect(GC.MaxGeneration);
+            GC.WaitForPendingFinalizers();
+        }
+
+        [Test]
+        public void TestDestructor()
+        {
+            ForceGC();
+            int instanceCount = YogaNode.GetInstanceCount();
+            TestDestructorForGC(instanceCount);
+            ForceGC();
+            Assert.AreEqual(instanceCount, YogaNode.GetInstanceCount());
+        }
+
+        private void TestDestructorForGC(int instanceCount)
+        {
+            YogaNode node = new YogaNode();
+            Assert.IsNotNull(node);
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+            node = null;
+        }
+
+        [Test]
+        public void TestDestructorWithChildren()
+        {
+            ForceGC();
+            int instanceCount = YogaNode.GetInstanceCount();
+            TestDestructorWithChildrenForGC1(instanceCount);
+            ForceGC();
+            Assert.AreEqual(instanceCount, YogaNode.GetInstanceCount());
+        }
+
+        private void TestDestructorWithChildrenForGC1(int instanceCount)
+        {
+            YogaNode node = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+
+            TestDestructorWithChildrenForGC2(node, instanceCount + 1);
+            ForceGC();
+            Assert.AreEqual(instanceCount + 2, YogaNode.GetInstanceCount());
+
+            TestDestructorWithChildrenForGC2(node, instanceCount + 2);
+            ForceGC();
+            Assert.AreEqual(instanceCount + 3, YogaNode.GetInstanceCount());
+
+            node = null;
+        }
+
+        private void TestDestructorWithChildrenForGC2(YogaNode parent, int instanceCount)
+        {
+            YogaNode child = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+
+            parent.Insert(0, child);
+            child = null;
+        }
+
+        [Test]
+        public void TestParentDestructor()
+        {
+            ForceGC();
+            int instanceCount = YogaNode.GetInstanceCount();
+            YogaNode child = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+
+            TestParentDestructorForGC(child, instanceCount + 1);
+            ForceGC();
+
+            Assert.IsNull(child.Parent);
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+        }
+
+        private void TestParentDestructorForGC(YogaNode child, int instanceCount)
+        {
+            YogaNode parent = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+            parent.Insert(0, child);
+        }
+
+        [Test]
+        public void TestClearWithChildDestructor()
+        {
+            ForceGC();
+            int instanceCount = YogaNode.GetInstanceCount();
+            YogaNode node = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+            TestClearWithChildDestructorForGC(node, instanceCount + 1);
+            ForceGC();
+            Assert.AreEqual(instanceCount + 2, YogaNode.GetInstanceCount());
+            node.Clear();
+            Assert.AreEqual(0, node.Count);
+            ForceGC();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+        }
+
+        private void TestClearWithChildDestructorForGC(YogaNode parent, int instanceCount)
+        {
+            YogaNode child = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+            parent.Insert(0, child);
+        }
+
+        [Test]
+        public void TestMeasureFuncWithDestructor()
+        {
+            ForceGC();
+            int instanceCount = YogaNode.GetInstanceCount();
+            YogaNode parent = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+            TestMeasureFuncWithDestructorForGC(parent);
+            ForceGC();
+            Assert.AreEqual(instanceCount + 2, YogaNode.GetInstanceCount());
+            parent.CalculateLayout();
+            Assert.AreEqual(120, (int)parent.LayoutWidth);
+            Assert.AreEqual(130, (int)parent.LayoutHeight);
+        }
+
+        private void TestMeasureFuncWithDestructorForGC(YogaNode parent)
+        {
+            YogaNode child = new YogaNode();
+            parent.Insert(0, child);
+            child.SetMeasureFunction((_, width, widthMode, height, heightMode) => {
+                return MeasureOutput.Make(120, 130);
+            });
+        }
+#endif
+    }
+}

csharp/tests/Facebook.Yoga/test_macos.sh

@@ -0,0 +1,33 @@
+#!/bin/sh
+if clang --version >/dev/null 2>&1; then true; else
+  echo "ERROR: Can't execute clang. You need to install Xcode and command line tools."
+  exit 1
+fi
+
+if mcs --version >/dev/null 2>&1; then true; else
+  echo "ERROR: Can't execute mcs. You need to install Mono from http://www.mono-project.com/download/ and re-login to apply PATH environment."
+  exit 1
+fi
+
+if mono --version >/dev/null 2>&1; then true; else
+  echo "ERROR: Can't execute mono64. You need to install Mono from http://www.mono-project.com/download/ and re-login to apply PATH environment."
+  exit 1
+fi
+
+cd "$( dirname "$0" )"
+
+NUNIT=NUnit-2.6.4/bin
+if [ -d $NUNIT \
+    -a -f $NUNIT/nunit-console.exe \
+    -a -f $NUNIT/lib/nunit-console-runner.dll \
+    -a -f $NUNIT/lib/nunit.core.dll \
+    -a -f $NUNIT/lib/nunit.core.interfaces.dll \
+    -a -f $NUNIT/lib/nunit.util.dll ]; then true; else
+  curl -L -O https://github.com/nunit/nunitv2/releases/download/2.6.4/NUnit-2.6.4.zip
+  unzip -qq NUnit-2.6.4.zip
+  rm NUnit-2.6.4.zip
+fi
+
+clang -g -Wall -Wextra -dynamiclib -o libyoga.dylib -I../../.. ../../../CSSLayout/*.c ../../Yoga/YGInterop.cpp
+mcs -debug -t:library -r:$NUNIT/nunit.framework.dll -out:YogaTest.dll *.cs ../../../csharp/Facebook.Yoga/*cs
+MONO_PATH=$NUNIT mono --arch=64 --debug $NUNIT/nunit-console.exe YogaTest.dll

dist/README.md

@@ -1,12 +0,0 @@
-Releases can be found on [npm](https://www.npmjs.com/package/dss-layout).
-
-#Release Process
-
-```bash
-# Ensure that the local codebase is up to date
-git fetch upstream master && git checkout FETCH_HEAD
-
-npm version [<newversion> | major | minor | patch | premajor | preminor | prepatch | prerelease]
-```
-
-This will take care of getting the latest version of `upstream/master`, updating the package.json, committing, tagging and pushing back to `upstream/master`. Travis will then take care of building the packages and pushing to npm.

enums.py

@@ -0,0 +1,188 @@
+# Copyright (c) 2014-present, Facebook, Inc.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree. An additional grant
+# of patent rights can be found in the PATENTS file in the same directory.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+import os
+
+ENUMS = {
+    'Direction': [
+        'Inherit',
+        'LTR',
+        'RTL',
+    ],
+    'FlexDirection': [
+        'Column',
+        'ColumnReverse',
+        'Row',
+        'RowReverse',
+    ],
+    'Justify': [
+        'FlexStart',
+        'Center',
+        'FlexEnd',
+        'SpaceBetween',
+        'SpaceAround',
+    ],
+    'Overflow': [
+        'Visible',
+        'Hidden',
+        'Scroll',
+    ],
+    'Align': [
+        'Auto',
+        'FlexStart',
+        'Center',
+        'FlexEnd',
+        'Stretch',
+    ],
+    'PositionType': [
+        'Relative',
+        'Absolute',
+    ],
+    'Wrap': [
+        'NoWrap',
+        'Wrap',
+    ],
+    'MeasureMode': [
+        'Undefined',
+        'Exactly',
+        'AtMost',
+    ],
+    'Dimension': [
+        'Width',
+        'Height',
+    ],
+    'Edge': [
+        'Left',
+        'Top',
+        'Right',
+        'Bottom',
+        'Start',
+        'End',
+        'Horizontal',
+        'Vertical',
+        'All',
+    ],
+    'LogLevel': [
+        'Error',
+        'Warn',
+        'Info',
+        'Debug',
+        'Verbose',
+    ],
+    'ExperimentalFeature': [
+        'Rounding',
+        # Mimic web flex-basis behavior.
+        'WebFlexBasis',
+    ],
+    'PrintOptions': [
+        ('Layout', 1),
+        ('Style', 2),
+        ('Children', 4),
+    ],
+}
+
+LICENSE = """/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+"""
+
+def to_java_upper(symbol):
+    symbol = str(symbol)
+    out = ''
+    for i in range(0, len(symbol)):
+        c = symbol[i]
+        if str.istitle(c) and i is not 0 and not str.istitle(symbol[i - 1]):
+            out += '_'
+        out += c.upper()
+    return out
+
+
+root = os.path.dirname(__file__)
+
+# write out C header
+with open(root + '/CSSLayout/YGEnums.h', 'w') as f:
+    f.write(LICENSE)
+    remaining = len(ENUMS)
+    for name, values in ENUMS.items():
+        f.write('typedef enum YG%s {\n' % name)
+        for value in values:
+            if isinstance(value, tuple):
+                f.write('  YG%s%s = %d,\n' % (name, value[0], value[1]))
+            else:
+                f.write('  YG%s%s,\n' % (name, value))
+        f.write('  YG%sCount,\n' % name)
+        f.write('} YG%s;\n' % name)
+        if remaining > 1:
+            f.write('\n')
+        remaining = remaining - 1
+
+# write out java files
+for name, values in ENUMS.items():
+    with open(root + '/java/com/facebook/csslayout/Yoga%s.java' % name, 'w') as f:
+        f.write(LICENSE)
+        f.write('package com.facebook.csslayout;\n\n')
+        f.write('import com.facebook.proguard.annotations.DoNotStrip;\n\n')
+        f.write('@DoNotStrip\n')
+        f.write('public enum Yoga%s {\n' % name)
+        if len(values) > 0:
+            for value in values:
+                if isinstance(value, tuple):
+                    f.write('  %s(%d)' % (to_java_upper(value[0]), value[1]))
+                else:
+                    f.write('  %s(%d)' % (to_java_upper(value), values.index(value)))
+                if values.index(value) is len(values) - 1:
+                    f.write(';\n')
+                else:
+                    f.write(',\n')
+        else:
+            f.write('__EMPTY(-1);')
+        f.write('\n')
+        f.write('  private int mIntValue;\n')
+        f.write('\n')
+        f.write('  Yoga%s(int intValue) {\n' % name)
+        f.write('    mIntValue = intValue;\n')
+        f.write('  }\n')
+        f.write('\n')
+        f.write('  public int intValue() {\n')
+        f.write('    return mIntValue;\n')
+        f.write('  }\n')
+        f.write('\n')
+        f.write('  public static Yoga%s fromInt(int value) {\n' % name)
+        f.write('    switch (value) {\n')
+        for value in values:
+            if isinstance(value, tuple):
+                f.write('      case %d: return %s;\n' % (value[1], to_java_upper(value[0])))
+            else:
+                f.write('      case %d: return %s;\n' % (values.index(value), to_java_upper(value)))
+        f.write('      default: throw new IllegalArgumentException("Unkown enum value: " + value);\n')
+        f.write('    }\n')
+        f.write('  }\n')
+        f.write('}\n')
+
+# write out csharp files
+for name, values in ENUMS.items():
+    with open(root + '/csharp/Facebook.Yoga/Yoga%s.cs' % name, 'w') as f:
+        f.write(LICENSE)
+        f.write('namespace Facebook.Yoga\n{\n')
+        f.write('    public enum Yoga%s\n    {\n' % name)
+        for value in values:
+            if isinstance(value, tuple):
+                f.write('        %s = %d,\n' % (value[0], value[1]))
+            else:
+                f.write('        %s,\n' % value)
+        f.write('    }\n')
+        f.write('}\n')

format.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+
+clang-format \
+  -style="{ \
+    AlignAfterOpenBracket: Align, \
+    AlignEscapedNewlinesLeft: true, \
+    AlignOperands: true, \
+    AllowAllParametersOfDeclarationOnNextLine: false, \
+    AllowShortBlocksOnASingleLine: false, \
+    AllowShortCaseLabelsOnASingleLine: false, \
+    AllowShortFunctionsOnASingleLine: false, \
+    AllowShortIfStatementsOnASingleLine: false, \
+    AllowShortLoopsOnASingleLine: false, \
+    BinPackArguments: false, \
+    BinPackParameters: false, \
+    BreakBeforeBraces: Attach, \
+    ColumnLimit: 100, \
+    ContinuationIndentWidth: 4, \
+    IndentCaseLabels: true, \
+    IndentWidth: 2, \
+    KeepEmptyLinesAtTheStartOfBlocks: false, \
+    Language: Cpp, \
+    PenaltyBreakBeforeFirstCallParameter: 100, \
+    PenaltyBreakString: 1000, \
+    PenaltyExcessCharacter: 100, \
+    PenaltyReturnTypeOnItsOwnLine: 100, \
+    PointerAlignment: Right, \
+    SortIncludes: true, \
+    SpaceAfterCStyleCast: true, \
+    UseTab: Never, \
+  }" "$@" \
+  -i $(dirname $0)/CSSLayout/*.{h,c,cpp} \
+     $(dirname $0)/tests/CSSLayoutTestUtils/*.{h,c,cpp} \
+     $(dirname $0)/benchmarks/*.{h,c,cpp} \
+     $(dirname $0)/java/jni/*.{h,c,cpp}

gentest/fixtures/YGAbsolutePositionTest.html

@@ -0,0 +1,26 @@
+<div id="absolute_layout_width_height_start_top" style="width: 100px; height: 100px;">
+  <div style="width:10px; height: 10px; position: absolute; start: 10px; top: 10px;"></div>
+</div>
+
+<div id="absolute_layout_width_height_end_bottom" style="width: 100px; height: 100px;">
+  <div style="width:10px; height: 10px; position: absolute; end: 10px; bottom: 10px;"></div>
+</div>
+
+<div id="absolute_layout_start_top_end_bottom" style="width: 100px; height: 100px;">
+  <div style="position: absolute; start: 10px; top: 10px; end: 10px; bottom: 10px;"></div>
+</div>
+
+<div id="absolute_layout_width_height_start_top_end_bottom" style="width: 100px; height: 100px;">
+  <div style="width:10px; height: 10px; position: absolute; start: 10px; top: 10px; end: 10px; bottom: 10px;"></div>
+</div>
+
+<div id="do_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hidden_parent" style="height: 50px; width: 50px; overflow: hidden; flex-direction: row;">
+  <div style="position: absolute; start: 0px; top: 0px;">
+    <div style="width: 100px; height: 100px;"></div>
+  </div>
+</div>
+
+<div id="absolute_layout_within_border" style="height:100px; width:100px; border-width: 10px; margin: 10px; padding: 10px;">
+  <div style="position: absolute; width: 50px; height: 50px; left: 0px; top: 0px;"></div>
+  <div style="position: absolute; width: 50px; height: 50px; right: 0px; bottom: 0px;"></div>
+</div>

gentest/fixtures/YGAlignContentTest.html

@@ -0,0 +1,31 @@
+<div id="align_content_flex_start" style="width: 100px; height: 100px; flex-wrap: wrap; flex-direction: column; align-content: flex-start;">
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+</div>
+
+<div id="align_content_flex_end" style="width: 100px; height: 100px; flex-wrap: wrap; flex-direction: column; align-content: flex-end;">
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+</div>
+
+<div id="align_content_center" style="width: 100px; height: 100px; flex-wrap: wrap; flex-direction: column; align-content: center;">
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+  <div style="width: 50px; height: 10px;"></div>
+</div>
+
+<div id="align_content_stretch" style="width: 100px; height: 100px; flex-wrap: wrap; flex-direction: column; align-content: stretch;">
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+  <div style="width: 50px;"></div>
+</div>

gentest/fixtures/YGAlignItemsTest.html

@@ -0,0 +1,15 @@
+<div id="align_items_stretch" style="width: 100px; height: 100px;">
+  <div style="height: 10px;"></div>
+</div>
+
+<div id="align_items_center" style="width: 100px; height: 100px; align-items: center;">
+  <div style="height: 10px; width: 10px;"></div>
+</div>
+
+<div id="align_items_flex_start" style="width: 100px; height: 100px; align-items: flex-start;">
+  <div style="height: 10px; width: 10px;"></div>
+</div>
+
+<div id="align_items_flex_end" style="width: 100px; height: 100px; align-items: flex-end;">
+  <div style="height: 10px; width: 10px;"></div>
+</div>

gentest/fixtures/YGAlignSelfTest.html

@@ -0,0 +1,15 @@
+<div id="align_self_center" style="width:100px; height: 100px;">
+  <div style="height: 10px; width: 10px; align-self: center;"></div>
+</div>
+
+<div id="align_self_flex_end" style="width:100px; height: 100px;">
+  <div style="height: 10px; width: 10px; align-self: flex-end;"></div>
+</div>
+
+<div id="align_self_flex_start" style="width:100px; height: 100px;">
+  <div style="height: 10px; width: 10px; align-self: flex-start;"></div>
+</div>
+
+<div id="align_self_flex_end_override_flex_start" style="width:100px; height: 100px; align-items: flex-start;">
+  <div style="height: 10px; width: 10px; align-self: flex-end;"></div>
+</div>

gentest/fixtures/YGBorderTest.html

@@ -0,0 +1,18 @@
+<div id="border_no_size" style="border-width: 10px;">
+</div>
+
+<div id="border_container_match_child" style="border-width: 10px;">
+  <div style="width: 10px; height: 10px;"></div>
+</div>
+
+<div id="border_flex_child" style="width: 100px; height: 100px; border-width: 10px;">
+  <div style="width: 10px; flex-grow:1"></div>
+</div>
+
+<div id="border_stretch_child" style="width: 100px; height: 100px; border-width: 10px;">
+  <div style="height: 10px;"></div>
+</div>
+
+<div id="border_center_child" style="width: 100px; height: 100px; border-start-width: 10px; border-top-width: 10; border-end-width: 20px; border-bottom-width: 20px; align-items: center; justify-content: center;">
+  <div style="height: 10px; width: 10px;"></div>
+</div>

gentest/fixtures/YGFlexDirectionTest.html

@@ -0,0 +1,35 @@
+<div id="flex_direction_column_no_height" style="width: 100px">
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+</div>
+
+<div id="flex_direction_row_no_width" style="height: 100px; flex-direction: row;">
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+</div>
+
+<div id="flex_direction_column" style="height: 100px; width: 100px;">
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+</div>
+
+<div id="flex_direction_row" style="height: 100px; width: 100px; flex-direction: row;">
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+</div>
+
+<div id="flex_direction_column_reverse" style="height: 100px; width: 100px; flex-direction: column-reverse;">
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+</div>
+
+<div id="flex_direction_row_reverse" style="height: 100px; width: 100px; flex-direction: row-reverse;">
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+</div>

gentest/fixtures/YGFlexTest.html

@@ -0,0 +1,37 @@
+<div id="flex_basis_flex_grow_column" style="width: 100px; height: 100px;">
+  <div style="flex-basis: 50px; flex-grow: 1;"></div>
+  <div style="flex-grow: 1;"></div>
+</div>
+
+<div id="flex_basis_flex_grow_row" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="flex-basis: 50px; flex-grow: 1;"></div>
+  <div style="flex-grow: 1;"></div>
+</div>
+
+<div id="flex_basis_flex_shrink_column" style="width: 100px; height: 100px;">
+  <div style="flex-basis: 100px; flex-shrink: 1;"></div>
+  <div style="flex-basis: 50px;"></div>
+</div>
+
+<div id="flex_basis_flex_shrink_row" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="flex-basis: 100px; flex-shrink: 1;"></div>
+  <div style="flex-basis: 50px;"></div>
+</div>
+
+<div id="flex_shrink_to_zero" style="height: 75px;">
+  <div style="width: 50px; height: 50px; flex-shrink:0;"></div>
+  <div style="width: 50px; height: 50px; flex-shrink:1;"></div>
+  <div style="width: 50px; height: 50px; flex-shrink:0;"></div>
+</div>
+
+<div id="flex_basis_overrides_main_size" style="height: 100px; width: 100px;">
+  <div style="height: 20px; flex-grow:1; flex-basis:50px;"></div>
+  <div style="height: 10px; flex-grow:1;"></div>
+  <div style="height: 10px; flex-grow:1;"></div>
+</div>
+
+<div id="flex_grow_shrink_at_most" style="height: 100px; width: 100px;">
+  <div>
+    <div style="flex-grow:1; flex-shrink:1;"></div>
+  </div>
+</div>

gentest/fixtures/YGFlexWrapTest.html

@@ -0,0 +1,27 @@
+<div id="wrap_column" style="height: 100px; flex-wrap: wrap">
+  <div style="height: 30px; width: 30px;"></div>
+  <div style="height: 30px; width: 30px;"></div>
+  <div style="height: 30px; width: 30px;"></div>
+  <div style="height: 30px; width: 30px;"></div>
+</div>
+
+<div id="wrap_row" style="width: 100px; flex-direction: row; flex-wrap: wrap">
+  <div style="height: 30px; width: 30px;"></div>
+  <div style="height: 30px; width: 30px;"></div>
+  <div style="height: 30px; width: 30px;"></div>
+  <div style="height: 30px; width: 30px;"></div>
+</div>
+
+<div id="wrap_row_align_items_flex_end" style="width: 100px; flex-direction: row; flex-wrap: wrap; align-items: flex-end;">
+  <div style="height: 10px; width: 30px;"></div>
+  <div style="height: 20px; width: 30px;"></div>
+  <div style="height: 30px; width: 30px;"></div>
+  <div style="height: 30px; width: 30px;"></div>
+</div>
+
+<div id="wrap_row_align_items_center" style="width: 100px; flex-direction: row; flex-wrap: wrap; align-items: center;">
+  <div style="height: 10px; width: 30px;"></div>
+  <div style="height: 20px; width: 30px;"></div>
+  <div style="height: 30px; width: 30px;"></div>
+  <div style="height: 30px; width: 30px;"></div>
+</div>

gentest/fixtures/YGJustifyContentTest.html

@@ -0,0 +1,59 @@
+<div id="justify_content_row_flex_start" style="width: 102px; height: 102px; flex-direction: row; justify-content: flex-start;">
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+</div>
+
+<div id="justify_content_row_flex_end" style="width: 102px; height: 102px; flex-direction: row; justify-content: flex-end;">
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+</div>
+
+<div id="justify_content_row_center" style="width: 102px; height: 102px; flex-direction: row; justify-content: center;">
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+</div>
+
+<div id="justify_content_row_space_between" style="width: 102px; height: 102px; flex-direction: row; justify-content: space-between;">
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+</div>
+
+<div id="justify_content_row_space_around" style="width: 102px; height: 102px; flex-direction: row; justify-content: space-around;">
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+  <div style="width: 10px;"></div>
+</div>
+
+<div id="justify_content_column_flex_start" style="width: 102px; height: 102px; justify-content: flex-start;">
+  <div style="height: 10px;"></div>
+  <div style="heigth: 10px;"></div>
+  <div style="height: 10px;"></div>
+</div>
+
+<div id="justify_content_column_flex_end" style="width: 102px; height: 102px; justify-content: flex-end;">
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+</div>
+
+<div id="justify_content_column_center" style="width: 102px; height: 102px; justify-content: center;">
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+</div>
+
+<div id="justify_content_column_space_between" style="width: 102px; height: 102px; justify-content: space-between;">
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+</div>
+
+<div id="justify_content_column_space_around" style="width: 102px; height: 102px; justify-content: space-around;">
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+  <div style="height: 10px;"></div>
+</div>

gentest/fixtures/YGMarginTest.html

@@ -0,0 +1,41 @@
+<div id="margin_start" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="width: 10px; margin-start: 10px;"></div>
+</div>
+
+<div id="margin_top" style="width: 100px; height: 100px;">
+  <div style="height: 10px; margin-top: 10px;"></div>
+</div>
+
+<div id="margin_end" style="width: 100px; height: 100px; flex-direction: row; justify-content: flex-end;">
+  <div style="width: 10px; margin-end: 10px;"></div>
+</div>
+
+<div id="margin_bottom" style="width: 100px; height: 100px; justify-content: flex-end;">
+  <div style="height: 10px; margin-bottom: 10px;"></div>
+</div>
+
+<div id="margin_and_flex_row" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="margin-start: 10px; margin-end; 10px; flex-grow: 1;"></div>
+</div>
+
+<div id="margin_and_flex_column" style="width: 100px; height: 100px;">
+  <div style="margin-top: 10px; margin-bottom; 10px; flex-grow: 1;"></div>
+</div>
+
+<div id="margin_and_stretch_row" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="margin-top: 10px; margin-bottom; 10px; flex-grow: 1;"></div>
+</div>
+
+<div id="margin_and_stretch_column" style="width: 100px; height: 100px;">
+  <div style="margin-start: 10px; margin-end; 10px; flex-grow: 1;"></div>
+</div>
+
+<div id="margin_with_sibling_row" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="margin-end; 10px; flex-grow: 1;"></div>
+  <div style="flex-grow: 1;"></div>
+</div>
+
+<div id="margin_with_sibling_column" style="width: 100px; height: 100px;">
+  <div style="margin-bottom; 10px; flex-grow: 1;"></div>
+  <div style="flex-grow: 1;"></div>
+</div>

gentest/fixtures/YGMinMaxDimensionTest.html

@@ -0,0 +1,43 @@
+<div id="max_width" style="width: 100px; height: 100px;">
+  <div style="height: 10px; max-width: 50px;"></div>
+</div>
+
+<div id="max_height" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="width: 10px; max-height: 50px;"></div>
+</div>
+
+<div id="min_height" style="width: 100px; height: 100px;">
+  <div style="flex-grow: 1; min-height: 60px;"></div>
+  <div style="flex-grow: 1;"></div>
+</div>
+
+<div id="min_width" style="width: 100px; height: 100px; flex-direction: row">
+  <div style="flex-grow: 1; min-width: 60px;"></div>
+  <div style="flex-grow: 1;"></div>
+</div>
+
+<div id="justify_content_min_max" style="max-height: 200px; min-height: 100px; width: 100px; justify-content: center;">
+  <div style="width: 60px; height: 60px;"></div>
+</div>
+
+<div id="align_items_min_max" style="max-width: 200px; min-width: 100px; height: 100px; align-items: center;">
+  <div style="width: 60px; height: 60px;"></div>
+</div>
+
+<div id="justify_content_overflow_min_max" style="min-height: 100px; max-height: 110px; justify-content: center;">
+  <div style="width: 50px; height: 50px;"></div>
+  <div style="width: 50px; height: 50px;"></div>
+  <div style="width: 50px; height: 50px;"></div>
+</div>
+
+<div id="flex_grow_within_max_width" style="width: 200px; height: 100px;">
+  <div style="flex-direction: row; max-width: 100px;">
+    <div style="height: 20px; flex-grow: 1;"></div>
+  </div>
+</div>
+
+<div id="flex_grow_within_constrained_max_width" style="width: 200px; height: 100px;">
+  <div style="flex-direction: row; max-width: 300px;">
+    <div style="height: 20px; flex-grow: 1;"></div>
+  </div>
+</div>

gentest/fixtures/YGPaddingTest.html

@@ -0,0 +1,22 @@
+<div id="padding_no_size" style="padding: 10px;">
+</div>
+
+<div id="padding_container_match_child" style="padding: 10px;">
+  <div style="width: 10px; height: 10px;"></div>
+</div>
+
+<div id="padding_flex_child" style="width: 100px; height: 100px; padding: 10px;">
+  <div style="width: 10px; flex-grow:1"></div>
+</div>
+
+<div id="padding_stretch_child" style="width: 100px; height: 100px; padding: 10px;">
+  <div style="height: 10px;"></div>
+</div>
+
+<div id="padding_center_child" style="width: 100px; height: 100px; padding-start: 10px; padding-top: 10; padding-end: 20px; padding-bottom: 20px; align-items: center; justify-content: center;">
+  <div style="height: 10px; width: 10px;"></div>
+</div>
+
+<div id="child_with_padding_align_end" style="width: 200px; height: 200px; justify-content: flex-end; align-items: flex-end;">
+  <div style="width: 100px; height: 100px; padding: 20px;"></div>
+</div>