Merged

2016-12-08 21:19:10 +01:00
parent 38ae7ea4ec 73662ebf83
commit fd015ffa0b
255 changed files with 26415 additions and 22357 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -4,7 +4,6 @@
 /buck-out/
 /.buckconfig.local
 /.buckd
-/lib/gtest/googletest-*/
 /gentest/test.html

 # Visual studio code
--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "lib/gtest/googletest"]
+	path = lib/gtest/googletest
+	url = https://github.com/google/googletest.git
--- a/.hgignore
+++ b/.hgignore
@@ -4,7 +4,6 @@
 /buck-out/
 /.buckconfig.local
 /.buckd
-/lib/gtest/googletest-*/
 /gentest/test.html

 # Visual studio code
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,12 +14,17 @@ before_install:
  - 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

 script:
-  - buck test //:CSSLayout
+  - buck test //:yoga
  - buck test //java:java
-  - buck test //uikit/CSSLayout:CSSLayout
+  - 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
--- a/18
+++ b/18
@@ -5,7 +5,7 @@
 # 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('//CSSLAYOUT_DEFS')
+include_defs('//YOGA_DEFS')

 BASE_COMPILER_FLAGS = [
  '-fno-omit-frame-pointer',
@@ -20,18 +20,20 @@ GMOCK_OVERRIDE_FLAGS = [
  '-Wno-inconsistent-missing-override',
 ]

-COMPILER_FLAGS = BASE_COMPILER_FLAGS + ['-std=c11']
+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']),
+  name = 'yoga',
+  soname = 'libyogacore.$(ext)',
+  srcs = glob(['yoga/*.c']),
  tests=[':tests'],
-  exported_headers = subdir_glob([('', 'CSSLayout/*.h')]),
+  exported_headers = subdir_glob([('', 'yoga/*.h')]),
  header_namespace = '',
-  force_static = True,
  compiler_flags = COMPILER_FLAGS,
-  deps = [],
+  deps = [] if THIS_IS_FBOBJC else [
+    yoga_dep('lib/fb:ndklog'),
+  ],
  visibility = ['PUBLIC'],
 )

@@ -41,7 +43,7 @@ cxx_test(
  srcs = glob(['tests/*.cpp']),
  compiler_flags = TEST_COMPILER_FLAGS,
  deps = [
-    ':CSSLayout',
+    ':yoga',
    GTEST_TARGET,
  ],
  visibility = ['PUBLIC'],
--- a/7
+++ b/7
@@ -1,10 +1,7 @@
-# Contributing to css-layout
+# Contributing to yoga
 We want to make contributing to this project as easy and transparent as
 possible.

-## Our Development Process
-All the development is happening on GitHub first and we have internal tools to sync down to Facebook codebase.
-
 ## Pull Requests
 We actively welcome your pull requests.
 1. Fork the repo and create your branch from `master`.
@@ -32,5 +29,5 @@ outlined on that page and do not file a public issue.
 * format.sh

 ## License
-By contributing to css-layout, you agree that your contributions will be licensed
+By contributing to yoga, you agree that your contributions will be licensed
 under its BSD license.
--- a/CSSLayout/CSSLayout.c
+++ b/CSSLayout/CSSLayout.c
--- a/CSSLayout/CSSLayout.h
+++ b/CSSLayout/CSSLayout.h
@@ -1,249 +0,0 @@
-/**
- * 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 CSSUndefined NAN
-
-#include "CSSMacros.h"
-
-CSS_EXTERN_C_BEGIN
-
-typedef enum CSSDirection {
-  CSSDirectionInherit,
-  CSSDirectionLTR,
-  CSSDirectionRTL,
-} CSSDirection;
-
-typedef enum CSSFlexDirection {
-  CSSFlexDirectionColumn,
-  CSSFlexDirectionColumnReverse,
-  CSSFlexDirectionRow,
-  CSSFlexDirectionRowReverse,
-} CSSFlexDirection;
-
-typedef enum CSSJustify {
-  CSSJustifyFlexStart,
-  CSSJustifyCenter,
-  CSSJustifyFlexEnd,
-  CSSJustifySpaceBetween,
-  CSSJustifySpaceAround,
-} CSSJustify;
-
-typedef enum CSSOverflow {
-  CSSOverflowVisible,
-  CSSOverflowHidden,
-  CSSOverflowScroll,
-} CSSOverflow;
-
-// Note: auto is only a valid value for alignSelf. It is NOT a valid value for
-// alignItems.
-typedef enum CSSAlign {
-  CSSAlignAuto,
-  CSSAlignFlexStart,
-  CSSAlignCenter,
-  CSSAlignFlexEnd,
-  CSSAlignStretch,
-} CSSAlign;
-
-typedef enum CSSPositionType {
-  CSSPositionTypeRelative,
-  CSSPositionTypeAbsolute,
-} CSSPositionType;
-
-typedef enum CSSWrapType {
-  CSSWrapTypeNoWrap,
-  CSSWrapTypeWrap,
-} CSSWrapType;
-
-typedef enum CSSMeasureMode {
-  CSSMeasureModeUndefined,
-  CSSMeasureModeExactly,
-  CSSMeasureModeAtMost,
-  CSSMeasureModeCount,
-} CSSMeasureMode;
-
-typedef enum CSSDimension {
-  CSSDimensionWidth,
-  CSSDimensionHeight,
-} CSSDimension;
-
-typedef enum CSSEdge {
-  CSSEdgeLeft,
-  CSSEdgeTop,
-  CSSEdgeRight,
-  CSSEdgeBottom,
-  CSSEdgeStart,
-  CSSEdgeEnd,
-  CSSEdgeHorizontal,
-  CSSEdgeVertical,
-  CSSEdgeAll,
-  CSSEdgeCount,
-} CSSEdge;
-
-typedef enum CSSPrintOptions {
-  CSSPrintOptionsLayout = 1,
-  CSSPrintOptionsStyle = 2,
-  CSSPrintOptionsChildren = 4,
-} CSSPrintOptions;
-
-typedef struct CSSSize {
-  float width;
-  float height;
-} CSSSize;
-
-typedef struct CSSNode *CSSNodeRef;
-typedef CSSSize (*CSSMeasureFunc)(CSSNodeRef node,
-                                  float width,
-                                  CSSMeasureMode widthMode,
-                                  float height,
-                                  CSSMeasureMode heightMode);
-typedef void (*CSSPrintFunc)(CSSNodeRef node);
-typedef int (*CSSLogger)(const char *format, ...);
-
-#ifdef CSS_ASSERT_FAIL_ENABLED
-typedef void (*CSSAssertFailFunc)(const char *message);
-#endif
-
-// CSSNode
-WIN_EXPORT CSSNodeRef CSSNodeNew(void);
-WIN_EXPORT void CSSNodeInit(const CSSNodeRef node);
-WIN_EXPORT void CSSNodeFree(const CSSNodeRef node);
-WIN_EXPORT void CSSNodeFreeRecursive(const CSSNodeRef node);
-WIN_EXPORT void CSSNodeReset(const CSSNodeRef node);
-WIN_EXPORT int32_t CSSNodeGetInstanceCount(void);
-
-WIN_EXPORT void CSSNodeInsertChild(const CSSNodeRef node,
-                                   const CSSNodeRef child,
-                                   const uint32_t index);
-WIN_EXPORT void CSSNodeRemoveChild(const CSSNodeRef node, const CSSNodeRef child);
-WIN_EXPORT CSSNodeRef CSSNodeGetChild(const CSSNodeRef node, const uint32_t index);
-WIN_EXPORT uint32_t CSSNodeChildCount(const CSSNodeRef node);
-
-WIN_EXPORT void CSSNodeCalculateLayout(const CSSNodeRef node,
-                                       const float availableWidth,
-                                       const float availableHeight,
-                                       const CSSDirection parentDirection);
-
-// Mark a node as dirty. Only valid for nodes with a custom measure function
-// set.
-// CSSLayout knows when to mark all other nodes as dirty but because nodes with
-// measure functions
-// depends on information not known to CSSLayout they must perform this dirty
-// marking manually.
-WIN_EXPORT void CSSNodeMarkDirty(const CSSNodeRef node);
-WIN_EXPORT bool CSSNodeIsDirty(const CSSNodeRef node);
-
-WIN_EXPORT void CSSNodeHide(const CSSNodeRef node);
-WIN_EXPORT void CSSNodeShow(const CSSNodeRef node);
-WIN_EXPORT bool CSSNodeIsVisible(const CSSNodeRef node);
-  
-
-WIN_EXPORT void CSSNodePrint(const CSSNodeRef node, const CSSPrintOptions options);
-
-WIN_EXPORT bool CSSValueIsUndefined(const float value);
-
-WIN_EXPORT bool CSSNodeCanUseCachedMeasurement(const bool isTextNode,
-                                               const CSSMeasureMode widthMode,
-                                               const float width,
-                                               const CSSMeasureMode heightMode,
-                                               const float height,
-                                               const CSSMeasureMode lastWidthMode,
-                                               const float lastWidth,
-                                               const CSSMeasureMode lastHeightMode,
-                                               const float lastHeight,
-                                               const float lastComputedWidth,
-                                               const float lastComputedHeight,
-                                               const float marginRow,
-                                               const float marginColumn);
-
-#define CSS_NODE_PROPERTY(type, name, paramName)                           \
-  WIN_EXPORT void CSSNodeSet##name(const CSSNodeRef node, type paramName); \
-  WIN_EXPORT type CSSNodeGet##name(const CSSNodeRef node);
-
-#define CSS_NODE_STYLE_PROPERTY(type, name, paramName)                                \
-  WIN_EXPORT void CSSNodeStyleSet##name(const CSSNodeRef node, const type paramName); \
-  WIN_EXPORT type CSSNodeStyleGet##name(const CSSNodeRef node);
-
-#define CSS_NODE_STYLE_EDGE_PROPERTY(type, name, paramName)    \
-  WIN_EXPORT void CSSNodeStyleSet##name(const CSSNodeRef node, \
-                                        const CSSEdge edge,    \
-                                        const type paramName); \
-  WIN_EXPORT type CSSNodeStyleGet##name(const CSSNodeRef node, const CSSEdge edge);
-
-#define CSS_NODE_LAYOUT_PROPERTY(type, name) \
-  WIN_EXPORT type CSSNodeLayoutGet##name(const CSSNodeRef node);
-
-CSS_NODE_PROPERTY(void *, Context, context);
-CSS_NODE_PROPERTY(CSSMeasureFunc, MeasureFunc, measureFunc);
-CSS_NODE_PROPERTY(CSSPrintFunc, PrintFunc, printFunc);
-CSS_NODE_PROPERTY(bool, IsTextnode, isTextNode);
-CSS_NODE_PROPERTY(bool, HasNewLayout, hasNewLayout);
-
-CSS_NODE_STYLE_PROPERTY(CSSDirection, Direction, direction);
-CSS_NODE_STYLE_PROPERTY(CSSFlexDirection, FlexDirection, flexDirection);
-CSS_NODE_STYLE_PROPERTY(CSSJustify, JustifyContent, justifyContent);
-CSS_NODE_STYLE_PROPERTY(CSSAlign, AlignContent, alignContent);
-CSS_NODE_STYLE_PROPERTY(CSSAlign, AlignItems, alignItems);
-CSS_NODE_STYLE_PROPERTY(CSSAlign, AlignSelf, alignSelf);
-CSS_NODE_STYLE_PROPERTY(CSSPositionType, PositionType, positionType);
-CSS_NODE_STYLE_PROPERTY(CSSWrapType, FlexWrap, flexWrap);
-CSS_NODE_STYLE_PROPERTY(CSSOverflow, Overflow, overflow);
-
-WIN_EXPORT void CSSNodeStyleSetFlex(const CSSNodeRef node, const float flex);
-CSS_NODE_STYLE_PROPERTY(float, FlexGrow, flexGrow);
-CSS_NODE_STYLE_PROPERTY(float, FlexShrink, flexShrink);
-CSS_NODE_STYLE_PROPERTY(float, FlexBasis, flexBasis);
-
-CSS_NODE_STYLE_EDGE_PROPERTY(float, Position, position);
-CSS_NODE_STYLE_EDGE_PROPERTY(float, Margin, margin);
-CSS_NODE_STYLE_EDGE_PROPERTY(float, Padding, padding);
-CSS_NODE_STYLE_EDGE_PROPERTY(float, Border, border);
-
-CSS_NODE_STYLE_PROPERTY(float, Width, width);
-CSS_NODE_STYLE_PROPERTY(float, Height, height);
-CSS_NODE_STYLE_PROPERTY(float, MinWidth, minWidth);
-CSS_NODE_STYLE_PROPERTY(float, MinHeight, minHeight);
-CSS_NODE_STYLE_PROPERTY(float, MaxWidth, maxWidth);
-CSS_NODE_STYLE_PROPERTY(float, MaxHeight, maxHeight);
-
-CSS_NODE_LAYOUT_PROPERTY(float, Left);
-CSS_NODE_LAYOUT_PROPERTY(float, Top);
-CSS_NODE_LAYOUT_PROPERTY(float, Right);
-CSS_NODE_LAYOUT_PROPERTY(float, Bottom);
-CSS_NODE_LAYOUT_PROPERTY(float, Width);
-CSS_NODE_LAYOUT_PROPERTY(float, Height);
-CSS_NODE_LAYOUT_PROPERTY(CSSDirection, Direction);
-
-WIN_EXPORT void CSSLayoutSetLogger(CSSLogger logger);
-
-#ifdef CSS_ASSERT_FAIL_ENABLED
-// Assert
-WIN_EXPORT void CSSAssertSetFailFunc(CSSAssertFailFunc func);
-WIN_EXPORT void CSSAssertFail(const char *message);
-#endif
-
-CSS_EXTERN_C_END
--- a/CSSLayout/CSSNodeList.c
+++ b/CSSLayout/CSSNodeList.c
@@ -1,100 +0,0 @@
-/**
- * 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 "CSSNodeList.h"
-
-struct CSSNodeList {
-  uint32_t capacity;
-  uint32_t count;
-  CSSNodeRef *items;
-};
-
-CSSNodeListRef CSSNodeListNew(const uint32_t initialCapacity) {
-  const CSSNodeListRef list = malloc(sizeof(struct CSSNodeList));
-  CSS_ASSERT(list != NULL, "Could not allocate memory for list");
-
-  list->capacity = initialCapacity;
-  list->count = 0;
-  list->items = malloc(sizeof(CSSNodeRef) * list->capacity);
-  CSS_ASSERT(list->items != NULL, "Could not allocate memory for items");
-
-  return list;
-}
-
-void CSSNodeListFree(const CSSNodeListRef list) {
-  if (list) {
-    free(list->items);
-    free(list);
-  }
-}
-
-uint32_t CSSNodeListCount(const CSSNodeListRef list) {
-  if (list) {
-    return list->count;
-  }
-  return 0;
-}
-
-void CSSNodeListAdd(CSSNodeListRef *listp, const CSSNodeRef node) {
-  if (!*listp) {
-    *listp = CSSNodeListNew(4);
-  }
-  CSSNodeListInsert(listp, node, (*listp)->count);
-}
-
-void CSSNodeListInsert(CSSNodeListRef *listp, const CSSNodeRef node, const uint32_t index) {
-  if (!*listp) {
-    *listp = CSSNodeListNew(4);
-  }
-  CSSNodeListRef list = *listp;
-
-  if (list->count == list->capacity) {
-    list->capacity *= 2;
-    list->items = realloc(list->items, sizeof(CSSNodeRef) * list->capacity);
-    CSS_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;
-}
-
-CSSNodeRef CSSNodeListRemove(const CSSNodeListRef list, const uint32_t index) {
-  const CSSNodeRef 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;
-}
-
-CSSNodeRef CSSNodeListDelete(const CSSNodeListRef list, const CSSNodeRef node) {
-  for (uint32_t i = 0; i < list->count; i++) {
-    if (list->items[i] == node) {
-      return CSSNodeListRemove(list, i);
-    }
-  }
-
-  return NULL;
-}
-
-CSSNodeRef CSSNodeListGet(const CSSNodeListRef list, const uint32_t index) {
-  if (CSSNodeListCount(list) > 0) {
-    return list->items[index];
-  }
-
-  return NULL;
-}
--- a/CSSLayout/CSSNodeList.h
+++ b/CSSLayout/CSSNodeList.h
@@ -1,33 +0,0 @@
-/**
- * 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 "CSSLayout.h"
-#include "CSSMacros.h"
-
-CSS_EXTERN_C_BEGIN
-
-typedef struct CSSNodeList *CSSNodeListRef;
-
-CSSNodeListRef CSSNodeListNew(const uint32_t initialCapacity);
-void CSSNodeListFree(const CSSNodeListRef list);
-uint32_t CSSNodeListCount(const CSSNodeListRef list);
-void CSSNodeListAdd(CSSNodeListRef *listp, const CSSNodeRef node);
-void CSSNodeListInsert(CSSNodeListRef *listp, const CSSNodeRef node, const uint32_t index);
-CSSNodeRef CSSNodeListRemove(const CSSNodeListRef list, const uint32_t index);
-CSSNodeRef CSSNodeListDelete(const CSSNodeListRef list, const CSSNodeRef node);
-CSSNodeRef CSSNodeListGet(const CSSNodeListRef list, const uint32_t index);
-
-CSS_EXTERN_C_END
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 BSD License

-For css-layout software
+For yoga software

 Copyright (c) 2014-present, Facebook, Inc. All rights reserved.

--- a/9
+++ b/9
@@ -0,0 +1,9 @@
+The examples provided by Facebook are for non-commercial testing and evaluation
+purposes only. Facebook reserves all rights not expressly granted.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+FACEBOOK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 Additional Grant of Patent Rights Version 2

-"Software" means the CSS Layout software distributed by Facebook, Inc.
+"Software" means the yoga software distributed by Facebook, Inc.

 Facebook, Inc. (“Facebook”) hereby grants to each recipient of the Software
 (“you”) a perpetual, worldwide, royalty-free, non-exclusive, irrevocable
--- a/README.md
+++ b/README.md
@@ -1,156 +1,28 @@
-# CSSLayout [![Build Status](https://travis-ci.org/facebook/css-layout.svg?branch=master)](https://travis-ci.org/facebook/css-layout)
+# Yoga [![Build Status](https://travis-ci.org/facebook/yoga.svg?branch=master)](https://travis-ci.org/facebook/yoga)

-## 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.
+## Building
+Yoga builds with [buck](https://buckbuild.com). Make sure you install buck before contributing to Yoga. Yoga's main implementation is in C, with bindings to supported languages and frameworks. When making changes to Yoga please ensure the changes are also propagated to these bindings when applicable.

-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.
+## 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 tests for that change to ensure we don't break anything in the future. Tests are located in the `tests` directory. Run the tests by executing `buck test //:yoga`.

-
-## 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.
-
-### 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 {
-  box-sizing: border-box;
-  position: relative;
-
-  display: flex;
-  flex-direction: column;
-  align-items: stretch;
-  flex-shrink: 0;
-  align-content: flex-start;
-
-  border: 0 solid black;
-  margin: 0;
-  padding: 0;
-  min-width: 0;
-}
-```
-
- `box-sizing: border-box` is the most convenient way to express the relation between `width` and `borderWidth`.
- Everything is `display: flex` by default. All the behaviors of `block` and `inline-block` can be expressed in term of `flex` but not the opposite.
- 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`.
-
-### 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.
-
-### -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.
-
-
-## 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, CSSUndefined, CSSUndefined, CSSDirectionLTR);
-
-// Get for resulting layout
-CSSNodeLayoutGetLeft(root);
-CSSNodeLayoutGetTop(root);
-CSSNodeLayoutGetWidth(root);
-CSSNodeLayoutGetHeight(root);
-```
-
-### 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 `uikit/CSSLayout/UIView+CSSLayout.h`.
-
-```objective-c
-UIView *root = [UIView new];
-[root css_setUsesFlexbox:YES];
-[root css_setWidth:100];
-[root css_setHeight:100];
-
-for (NSUInteger i = 0; i < 10; i++) {
-  UIView *child = [UIView new];
-  [child css_setUsesFlexbox:YES];
-  [child css_setHeight:10];
-  [root addSubview:child];
-}
-
-// Resulting layout will be set on the UIView hierarchy frames.
-[root css_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.
+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 Yoga, in `gentest/fixtures` folder, such as the following.

 ```html
-<div style="width: 100px; height: 100px; align-items: center;">
+<div id="my_test" 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.
+Run `gentest/gentest.rb` to generate test code and re-run `buck test //:yoga` 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.

-### 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.
+### .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.Yoga/test_macos.sh`.
+
+## Code style
+For the main C implementation of Yoga clang-format is used to ensure a consistent code style. Please run `bash format.sh` before submitting a pull request. For other languages just try to follow the current code style.
+
+## Benchmarks
+Benchmarks are located in `benchmarks/YGBenchmark.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. Benchmarks are run on every commit in CI.
--- a/11
+++ b/11
@@ -1,20 +1,23 @@

-CSSLAYOUT_ROOT = '//...'
+YOGA_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'
-GTEST_DL_URL = 'https://github.com/google/googletest/archive/release-1.7.0.zip'
-JNI_DEPS = ['//lib/fb:fbjni']
+JNI_TARGET = '//lib/jni:jni'
+FBJNI_TARGET = '//lib/fb:fbjni'
+
+THIS_IS_FBOBJC = False

 CXX_LIBRARY_WHITELIST = [
+  '//:yoga',
  '//lib/fb:fbjni',
  '//java:jni',
 ]

-def csslayout_dep(dep):
+def yoga_dep(dep):
  return '//' + dep

 class allow_unsafe_import:
--- a/uikit/CSSLayout/BUCK
+++ b/uikit/CSSLayout/BUCK
@@ -5,14 +5,32 @@
 # 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('//CSSLAYOUT_DEFS')
+include_defs('//YOGA_DEFS')

-UIKIT_CSSLAYOUT_COMPILER_FLAGS = ['-fobjc-arc']
+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 = 'CSSLayout',
-  compiler_flags = UIKIT_CSSLAYOUT_COMPILER_FLAGS,
-  tests = [':CSSLayoutTests'],
+  name = 'YogaKit',
+  compiler_flags = COMPILER_FLAGS,
+  tests = [':YogaKitTests'],
  srcs = glob(['*.m']),
  exported_headers = glob(['*.h']),
  frameworks = [
@@ -20,14 +38,14 @@ apple_library(
    '$SDKROOT/System/Library/Frameworks/UIKit.framework',
  ],
  deps = [
-    csslayout_dep(':CSSLayout'),
+    yoga_dep(':yoga'),
  ],
  visibility = ['PUBLIC'],
 )

 apple_test(
-  name = 'CSSLayoutTests',
-  compiler_flags = UIKIT_CSSLAYOUT_COMPILER_FLAGS,
+  name = 'YogaKitTests',
+  compiler_flags = COMPILER_FLAGS,
  info_plist = 'Tests/Info.plist',
  srcs = glob(['Tests/**/*.m']),
  frameworks = [
@@ -35,7 +53,7 @@ apple_test(
    '$PLATFORM_DIR/Developer/Library/Frameworks/XCTest.framework',
  ],
  deps = [
-    ':CSSLayout',
+    ':YogaKit',
  ],
  visibility = ['PUBLIC'],
 )
--- a/uikit/CSSLayout/Tests/Info.plist
+++ b/uikit/CSSLayout/Tests/Info.plist
--- a/YogaKit/Tests/YogaKitTests.m
+++ b/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
--- a/YogaKit/UIView+Yoga.h
+++ b/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 <yoga/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
--- a/YogaKit/UIView+Yoga.m
+++ b/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
+{
+  YGSetExperimentalFeatureEnabled(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
--- a/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/project.pbxproj
+++ b/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/project.pbxproj
@@ -0,0 +1,376 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		13687D481DF8748400E7C260 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 13687D471DF8748400E7C260 /* main.m */; };
+		13687D4B1DF8748400E7C260 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 13687D4A1DF8748400E7C260 /* AppDelegate.m */; };
+		13687D4E1DF8748400E7C260 /* ViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 13687D4D1DF8748400E7C260 /* ViewController.m */; };
+		13687D531DF8748400E7C260 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 13687D521DF8748400E7C260 /* Assets.xcassets */; };
+		13687D781DF878C600E7C260 /* YGEnums.h in yoga */ = {isa = PBXBuildFile; fileRef = 13687D5E1DF8778F00E7C260 /* YGEnums.h */; };
+		13687D791DF878C600E7C260 /* YGMacros.h in yoga */ = {isa = PBXBuildFile; fileRef = 13687D5F1DF8778F00E7C260 /* YGMacros.h */; };
+		13687D7A1DF878C600E7C260 /* Yoga.h in yoga */ = {isa = PBXBuildFile; fileRef = 13687D631DF8778F00E7C260 /* Yoga.h */; };
+		13687D7C1DF878DD00E7C260 /* UIView+Yoga.h in YogaKit */ = {isa = PBXBuildFile; fileRef = 13687D691DF8778F00E7C260 /* UIView+Yoga.h */; };
+		13687D801DF87CEC00E7C260 /* UIView+Yoga.m in Sources */ = {isa = PBXBuildFile; fileRef = 13687D6A1DF8778F00E7C260 /* UIView+Yoga.m */; };
+		13687D811DF87CF200E7C260 /* YGNodeList.c in Sources */ = {isa = PBXBuildFile; fileRef = 13687D601DF8778F00E7C260 /* YGNodeList.c */; };
+		13687D821DF87CF200E7C260 /* Yoga.c in Sources */ = {isa = PBXBuildFile; fileRef = 13687D621DF8778F00E7C260 /* Yoga.c */; };
+		13687D851DF87D1E00E7C260 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 13687D841DF87D1E00E7C260 /* UIKit.framework */; };
+		13687D871DF87D2400E7C260 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 13687D861DF87D2400E7C260 /* Foundation.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		13687D771DF878A000E7C260 /* yoga */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = include/yoga;
+			dstSubfolderSpec = 16;
+			files = (
+				13687D781DF878C600E7C260 /* YGEnums.h in yoga */,
+				13687D791DF878C600E7C260 /* YGMacros.h in yoga */,
+				13687D7A1DF878C600E7C260 /* Yoga.h in yoga */,
+			);
+			name = yoga;
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		13687D7B1DF878CE00E7C260 /* YogaKit */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = include/YogaKit;
+			dstSubfolderSpec = 16;
+			files = (
+				13687D7C1DF878DD00E7C260 /* UIView+Yoga.h in YogaKit */,
+			);
+			name = YogaKit;
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		13687D431DF8748400E7C260 /* YogaKitSample.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = YogaKitSample.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		13687D471DF8748400E7C260 /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = "<group>"; };
+		13687D491DF8748400E7C260 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = "<group>"; };
+		13687D4A1DF8748400E7C260 /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = "<group>"; };
+		13687D4C1DF8748400E7C260 /* ViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ViewController.h; sourceTree = "<group>"; };
+		13687D4D1DF8748400E7C260 /* ViewController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ViewController.m; sourceTree = "<group>"; };
+		13687D521DF8748400E7C260 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		13687D571DF8748400E7C260 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		13687D5E1DF8778F00E7C260 /* YGEnums.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = YGEnums.h; sourceTree = "<group>"; };
+		13687D5F1DF8778F00E7C260 /* YGMacros.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = YGMacros.h; sourceTree = "<group>"; };
+		13687D601DF8778F00E7C260 /* YGNodeList.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = YGNodeList.c; sourceTree = "<group>"; };
+		13687D611DF8778F00E7C260 /* YGNodeList.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = YGNodeList.h; sourceTree = "<group>"; };
+		13687D621DF8778F00E7C260 /* Yoga.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = Yoga.c; sourceTree = "<group>"; };
+		13687D631DF8778F00E7C260 /* Yoga.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = Yoga.h; sourceTree = "<group>"; };
+		13687D691DF8778F00E7C260 /* UIView+Yoga.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "UIView+Yoga.h"; sourceTree = "<group>"; };
+		13687D6A1DF8778F00E7C260 /* UIView+Yoga.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "UIView+Yoga.m"; sourceTree = "<group>"; };
+		13687D841DF87D1E00E7C260 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; };
+		13687D861DF87D2400E7C260 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		13687D401DF8748300E7C260 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				13687D871DF87D2400E7C260 /* Foundation.framework in Frameworks */,
+				13687D851DF87D1E00E7C260 /* UIKit.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		13687D3A1DF8748300E7C260 = {
+			isa = PBXGroup;
+			children = (
+				13687D5D1DF8778F00E7C260 /* yoga */,
+				13687D641DF8778F00E7C260 /* YogaKit */,
+				13687D451DF8748400E7C260 /* YogaKitSample */,
+				13687D441DF8748400E7C260 /* Products */,
+				13687D831DF87D1E00E7C260 /* Frameworks */,
+			);
+			sourceTree = "<group>";
+		};
+		13687D441DF8748400E7C260 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				13687D431DF8748400E7C260 /* YogaKitSample.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		13687D451DF8748400E7C260 /* YogaKitSample */ = {
+			isa = PBXGroup;
+			children = (
+				13687D491DF8748400E7C260 /* AppDelegate.h */,
+				13687D4A1DF8748400E7C260 /* AppDelegate.m */,
+				13687D4C1DF8748400E7C260 /* ViewController.h */,
+				13687D4D1DF8748400E7C260 /* ViewController.m */,
+				13687D521DF8748400E7C260 /* Assets.xcassets */,
+				13687D571DF8748400E7C260 /* Info.plist */,
+				13687D461DF8748400E7C260 /* Supporting Files */,
+			);
+			path = YogaKitSample;
+			sourceTree = "<group>";
+		};
+		13687D461DF8748400E7C260 /* Supporting Files */ = {
+			isa = PBXGroup;
+			children = (
+				13687D471DF8748400E7C260 /* main.m */,
+			);
+			name = "Supporting Files";
+			sourceTree = "<group>";
+		};
+		13687D5D1DF8778F00E7C260 /* yoga */ = {
+			isa = PBXGroup;
+			children = (
+				13687D5E1DF8778F00E7C260 /* YGEnums.h */,
+				13687D5F1DF8778F00E7C260 /* YGMacros.h */,
+				13687D601DF8778F00E7C260 /* YGNodeList.c */,
+				13687D611DF8778F00E7C260 /* YGNodeList.h */,
+				13687D621DF8778F00E7C260 /* Yoga.c */,
+				13687D631DF8778F00E7C260 /* Yoga.h */,
+			);
+			name = yoga;
+			path = ../../yoga;
+			sourceTree = "<group>";
+		};
+		13687D641DF8778F00E7C260 /* YogaKit */ = {
+			isa = PBXGroup;
+			children = (
+				13687D691DF8778F00E7C260 /* UIView+Yoga.h */,
+				13687D6A1DF8778F00E7C260 /* UIView+Yoga.m */,
+			);
+			name = YogaKit;
+			path = ..;
+			sourceTree = "<group>";
+		};
+		13687D831DF87D1E00E7C260 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				13687D861DF87D2400E7C260 /* Foundation.framework */,
+				13687D841DF87D1E00E7C260 /* UIKit.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		13687D421DF8748300E7C260 /* YogaKitSample */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 13687D5A1DF8748400E7C260 /* Build configuration list for PBXNativeTarget "YogaKitSample" */;
+			buildPhases = (
+				13687D771DF878A000E7C260 /* yoga */,
+				13687D7B1DF878CE00E7C260 /* YogaKit */,
+				13687D3F1DF8748300E7C260 /* Sources */,
+				13687D401DF8748300E7C260 /* Frameworks */,
+				13687D411DF8748300E7C260 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = YogaKitSample;
+			productName = YogaKitSample;
+			productReference = 13687D431DF8748400E7C260 /* YogaKitSample.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		13687D3B1DF8748300E7C260 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0810;
+				ORGANIZATIONNAME = facebook;
+				TargetAttributes = {
+					13687D421DF8748300E7C260 = {
+						CreatedOnToolsVersion = 8.1;
+						ProvisioningStyle = Automatic;
+					};
+				};
+			};
+			buildConfigurationList = 13687D3E1DF8748300E7C260 /* Build configuration list for PBXProject "YogaKitSample" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 13687D3A1DF8748300E7C260;
+			productRefGroup = 13687D441DF8748400E7C260 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				13687D421DF8748300E7C260 /* YogaKitSample */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		13687D411DF8748300E7C260 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				13687D531DF8748400E7C260 /* Assets.xcassets in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		13687D3F1DF8748300E7C260 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				13687D801DF87CEC00E7C260 /* UIView+Yoga.m in Sources */,
+				13687D4E1DF8748400E7C260 /* ViewController.m in Sources */,
+				13687D4B1DF8748400E7C260 /* AppDelegate.m in Sources */,
+				13687D821DF87CF200E7C260 /* Yoga.c in Sources */,
+				13687D811DF87CF200E7C260 /* YGNodeList.c in Sources */,
+				13687D481DF8748400E7C260 /* main.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		13687D581DF8748400E7C260 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_SUSPICIOUS_MOVES = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 10.1;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+			};
+			name = Debug;
+		};
+		13687D591DF8748400E7C260 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_SUSPICIOUS_MOVES = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 10.1;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		13687D5B1DF8748400E7C260 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				INFOPLIST_FILE = YogaKitSample/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
+				PRODUCT_BUNDLE_IDENTIFIER = com.facebook.YogaKitSample;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		13687D5C1DF8748400E7C260 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				INFOPLIST_FILE = YogaKitSample/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
+				PRODUCT_BUNDLE_IDENTIFIER = com.facebook.YogaKitSample;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		13687D3E1DF8748300E7C260 /* Build configuration list for PBXProject "YogaKitSample" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				13687D581DF8748400E7C260 /* Debug */,
+				13687D591DF8748400E7C260 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		13687D5A1DF8748400E7C260 /* Build configuration list for PBXNativeTarget "YogaKitSample" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				13687D5B1DF8748400E7C260 /* Debug */,
+				13687D5C1DF8748400E7C260 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 13687D3B1DF8748300E7C260 /* Project object */;
+}
--- a/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/project.xcworkspace/contents.xcworkspacedata
+++ b/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/project.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:YogaKitSample.xcodeproj">
+   </FileRef>
+</Workspace>
--- a/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/project.xcworkspace/xcuserdata/emilsj.xcuserdatad/UserInterfaceState.xcuserstate
+++ b/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/project.xcworkspace/xcuserdata/emilsj.xcuserdatad/UserInterfaceState.xcuserstate
--- a/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/xcuserdata/emilsj.xcuserdatad/xcschemes/YogaKitSample.xcscheme
+++ b/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/xcuserdata/emilsj.xcuserdatad/xcschemes/YogaKitSample.xcscheme
@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0810"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "13687D421DF8748300E7C260"
+               BuildableName = "YogaKitSample.app"
+               BlueprintName = "YogaKitSample"
+               ReferencedContainer = "container:YogaKitSample.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+      </Testables>
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "13687D421DF8748300E7C260"
+            BuildableName = "YogaKitSample.app"
+            BlueprintName = "YogaKitSample"
+            ReferencedContainer = "container:YogaKitSample.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "13687D421DF8748300E7C260"
+            BuildableName = "YogaKitSample.app"
+            BlueprintName = "YogaKitSample"
+            ReferencedContainer = "container:YogaKitSample.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "13687D421DF8748300E7C260"
+            BuildableName = "YogaKitSample.app"
+            BlueprintName = "YogaKitSample"
+            ReferencedContainer = "container:YogaKitSample.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
--- a/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/xcuserdata/emilsj.xcuserdatad/xcschemes/xcschememanagement.plist
+++ b/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/xcuserdata/emilsj.xcuserdatad/xcschemes/xcschememanagement.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>SchemeUserState</key>
+	<dict>
+		<key>YogaKitSample.xcscheme</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>0</integer>
+		</dict>
+	</dict>
+	<key>SuppressBuildableAutocreation</key>
+	<dict>
+		<key>13687D421DF8748300E7C260</key>
+		<dict>
+			<key>primary</key>
+			<true/>
+		</dict>
+	</dict>
+</dict>
+</plist>
--- a/YogaKit/YogaKitSample/YogaKitSample/AppDelegate.h
+++ b/YogaKit/YogaKitSample/YogaKitSample/AppDelegate.h
@@ -0,0 +1,16 @@
+/**
+ * Copyright 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the license found in the
+ * LICENSE-examples file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+@interface AppDelegate : UIResponder <UIApplicationDelegate>
+
+@property (strong, nonatomic) UIWindow *window;
+
+@end
+
--- a/YogaKit/YogaKitSample/YogaKitSample/AppDelegate.m
+++ b/YogaKit/YogaKitSample/YogaKitSample/AppDelegate.m
@@ -0,0 +1,27 @@
+/**
+ * Copyright 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the license found in the
+ * LICENSE-examples file in the root directory of this source tree.
+ */
+
+#import "AppDelegate.h"
+#import "ViewController.h"
+
+@interface AppDelegate ()
+
+@end
+
+@implementation AppDelegate
+
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
+    self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
+    self.window.rootViewController = [ViewController new];
+    self.window.backgroundColor = [UIColor whiteColor];
+    [self.window makeKeyAndVisible];
+    return YES;
+}
+
+@end
--- a/YogaKit/YogaKitSample/YogaKitSample/Assets.xcassets/AppIcon.appiconset/Contents.json
+++ b/YogaKit/YogaKitSample/YogaKitSample/Assets.xcassets/AppIcon.appiconset/Contents.json
@@ -0,0 +1,48 @@
+{
+  "images" : [
+    {
+      "idiom" : "iphone",
+      "size" : "20x20",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "20x20",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "29x29",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "29x29",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "40x40",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "40x40",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "60x60",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "60x60",
+      "scale" : "3x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}
--- a/YogaKit/YogaKitSample/YogaKitSample/Info.plist
+++ b/YogaKit/YogaKitSample/YogaKitSample/Info.plist
@@ -0,0 +1,36 @@
+<?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>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UILaunchStoryboardName</key>
+	<string></string>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>armv7</string>
+	</array>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+</dict>
+</plist>
--- a/YogaKit/YogaKitSample/YogaKitSample/ViewController.h
+++ b/YogaKit/YogaKitSample/YogaKitSample/ViewController.h
@@ -0,0 +1,15 @@
+/**
+ * Copyright 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the license found in the
+ * LICENSE-examples file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+@interface ViewController : UIViewController
+
+
+@end
+
--- a/YogaKit/YogaKitSample/YogaKitSample/ViewController.m
+++ b/YogaKit/YogaKitSample/YogaKitSample/ViewController.m
@@ -0,0 +1,60 @@
+/**
+ * Copyright 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the license found in the
+ * LICENSE-examples file in the root directory of this source tree.
+ */
+
+#import "ViewController.h"
+
+#import <YogaKit/UIView+Yoga.h>
+
+@interface ViewController ()
+
+@end
+
+@implementation ViewController
+
+- (void)viewDidLoad
+{
+    UIView *root = self.view;
+    root.backgroundColor = [UIColor redColor];
+    [root yg_setUsesYoga:YES];
+    [root yg_setWidth:self.view.bounds.size.width];
+    [root yg_setHeight:self.view.bounds.size.height];
+    [root yg_setAlignItems:YGAlignCenter];
+    [root yg_setJustifyContent:YGJustifyCenter];
+
+    UIView *child1 = [UIView new];
+    child1.backgroundColor = [UIColor blueColor];
+    [child1 yg_setUsesYoga:YES];
+    [child1 yg_setWidth:100];
+    [child1 yg_setHeight:100];
+
+    UIView *child2 = [UIView new];
+    child2.backgroundColor = [UIColor greenColor];
+    child2.frame = (CGRect) {
+        .size = {
+            .width = 200,
+            .height = 100,
+        }
+    };
+
+    UIView *child3 = [UIView new];
+    child3.backgroundColor = [UIColor yellowColor];
+    child3.frame = (CGRect) {
+        .size = {
+            .width = 100,
+            .height = 100,
+        }
+    };
+
+    [child2 addSubview:child3];
+    [root addSubview:child1];
+    [root addSubview:child2];
+    [root yg_applyLayout];
+}
+
+
+@end
--- a/YogaKit/YogaKitSample/YogaKitSample/main.m
+++ b/YogaKit/YogaKitSample/YogaKitSample/main.m
@@ -0,0 +1,16 @@
+/**
+ * Copyright 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the license found in the
+ * LICENSE-examples file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+#import "AppDelegate.h"
+
+int main(int argc, char * argv[]) {
+    @autoreleasepool {
+        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
+    }
+}
--- a/benchmark/BUCK
+++ b/benchmark/BUCK
@@ -5,7 +5,7 @@
 # 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('//CSSLAYOUT_DEFS')
+include_defs('//YOGA_DEFS')

 cxx_binary(
  name = 'benchmark',
@@ -21,7 +21,7 @@ cxx_binary(
    '-std=c11',
  ],
  deps = [
-    csslayout_dep(':CSSLayout'),
+    yoga_dep(':yoga'),
  ],
  visibility = ['PUBLIC'],
 )
--- a/benchmark/CSSBenchmark.c
+++ b/benchmark/CSSBenchmark.c
@@ -1,119 +0,0 @@
-/**
- * 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 "CSSBenchmark.h"
-
-#include <CSSLayout/CSSLayout.h>
-
-static CSSSize _measure(CSSNodeRef node,
-                        float width,
-                        CSSMeasureMode widthMode,
-                        float height,
-                        CSSMeasureMode heightMode) {
-  return (CSSSize){
-      .width = widthMode == CSSMeasureModeUndefined ? 10 : width,
-      .height = heightMode == CSSMeasureModeUndefined ? 10 : width,
-  };
-}
-
-CSS_BENCHMARKS({
-
-  CSS_BENCHMARK("Stack with flex", {
-    const CSSNodeRef root = CSSNodeNew();
-    CSSNodeStyleSetWidth(root, 100);
-    CSSNodeStyleSetHeight(root, 100);
-
-    for (uint32_t i = 0; i < 10; i++) {
-      const CSSNodeRef child = CSSNodeNew();
-      CSSNodeSetMeasureFunc(child, _measure);
-      CSSNodeStyleSetFlex(child, 1);
-      CSSNodeInsertChild(root, child, 0);
-    }
-
-    CSSNodeCalculateLayout(root, CSSUndefined, CSSUndefined, CSSDirectionLTR);
-    CSSNodeFreeRecursive(root);
-  });
-
-  CSS_BENCHMARK("Align stretch in undefined axis", {
-    const CSSNodeRef root = CSSNodeNew();
-
-    for (uint32_t i = 0; i < 10; i++) {
-      const CSSNodeRef child = CSSNodeNew();
-      CSSNodeStyleSetHeight(child, 20);
-      CSSNodeSetMeasureFunc(child, _measure);
-      CSSNodeInsertChild(root, child, 0);
-    }
-
-    CSSNodeCalculateLayout(root, CSSUndefined, CSSUndefined, CSSDirectionLTR);
-    CSSNodeFreeRecursive(root);
-  });
-
-  CSS_BENCHMARK("Nested flex", {
-    const CSSNodeRef root = CSSNodeNew();
-
-    for (uint32_t i = 0; i < 10; i++) {
-      const CSSNodeRef child = CSSNodeNew();
-      CSSNodeSetMeasureFunc(child, _measure);
-      CSSNodeStyleSetFlex(child, 1);
-      CSSNodeInsertChild(root, child, 0);
-
-      for (uint32_t ii = 0; ii < 10; ii++) {
-        const CSSNodeRef grandChild = CSSNodeNew();
-        CSSNodeSetMeasureFunc(grandChild, _measure);
-        CSSNodeStyleSetFlex(grandChild, 1);
-        CSSNodeInsertChild(child, grandChild, 0);
-      }
-    }
-
-    CSSNodeCalculateLayout(root, CSSUndefined, CSSUndefined, CSSDirectionLTR);
-    CSSNodeFreeRecursive(root);
-  });
-
-  CSS_BENCHMARK("Huge nested layout", {
-    const CSSNodeRef root = CSSNodeNew();
-
-    for (uint32_t i = 0; i < 10; i++) {
-      const CSSNodeRef child = CSSNodeNew();
-      CSSNodeStyleSetFlexGrow(child, 1);
-      CSSNodeStyleSetWidth(child, 10);
-      CSSNodeStyleSetHeight(child, 10);
-      CSSNodeInsertChild(root, child, 0);
-
-      for (uint32_t ii = 0; ii < 10; ii++) {
-        const CSSNodeRef grandChild = CSSNodeNew();
-        CSSNodeStyleSetFlexDirection(grandChild, CSSFlexDirectionRow);
-        CSSNodeStyleSetFlexGrow(grandChild, 1);
-        CSSNodeStyleSetWidth(grandChild, 10);
-        CSSNodeStyleSetHeight(grandChild, 10);
-        CSSNodeInsertChild(child, grandChild, 0);
-
-        for (uint32_t iii = 0; iii < 10; iii++) {
-          const CSSNodeRef grandGrandChild = CSSNodeNew();
-          CSSNodeStyleSetFlexGrow(grandGrandChild, 1);
-          CSSNodeStyleSetWidth(grandGrandChild, 10);
-          CSSNodeStyleSetHeight(grandGrandChild, 10);
-          CSSNodeInsertChild(grandChild, grandGrandChild, 0);
-
-          for (uint32_t iii = 0; iii < 10; iii++) {
-            const CSSNodeRef grandGrandGrandChild = CSSNodeNew();
-            CSSNodeStyleSetFlexDirection(grandGrandGrandChild, CSSFlexDirectionRow);
-            CSSNodeStyleSetFlexGrow(grandGrandGrandChild, 1);
-            CSSNodeStyleSetWidth(grandGrandGrandChild, 10);
-            CSSNodeStyleSetHeight(grandGrandGrandChild, 10);
-            CSSNodeInsertChild(grandGrandChild, grandGrandGrandChild, 0);
-          }
-        }
-      }
-    }
-
-    CSSNodeCalculateLayout(root, CSSUndefined, CSSUndefined, CSSDirectionLTR);
-    CSSNodeFreeRecursive(root);
-  });
-
-});
--- a/benchmark/YGBenchmark.c
+++ b/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 <yoga/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);
+  });
+
+});
--- a/benchmark/CSSBenchmark.h
+++ b/benchmark/CSSBenchmark.h
@@ -17,7 +17,7 @@

 #define NUM_REPETITIONS 1000

-#define CSS_BENCHMARKS(BLOCK)              \
+#define YGBENCHMARKS(BLOCK)              \
  int main(int argc, char const *argv[]) { \
    clock_t __start;                       \
    clock_t __endTimes[NUM_REPETITIONS];   \
@@ -25,7 +25,7 @@
    return 0;                              \
  }

-#define CSS_BENCHMARK(NAME, BLOCK)                       \
+#define YGBENCHMARK(NAME, BLOCK)                       \
  __start = clock();                                     \
  for (uint32_t __i = 0; __i < NUM_REPETITIONS; __i++) { \
    { BLOCK }                                            \
--- a/csharp/.gitignore
+++ b/csharp/.gitignore
@@ -30,6 +30,11 @@ bld/
 # MSTest test Results
 [Tt]est[Rr]esult*/
 [Bb]uild[Ll]og.*
+csharp/tests/Facebook.Yoga/NUnit-[0-9\.]+/
+csharp/tests/Facebook.Yoga/YogaTest.dll
+csharp/tests/Facebook.Yoga/YogaTest.dll.mdb
+csharp/tests/Facebook.Yoga/libyoga.dylib
+csharp/tests/Facebook.Yoga/libyoga.dylib.dSYM/

 # NUNIT
 *.VisualState.xml
--- a/csharp/.hgignore
+++ b/csharp/.hgignore
@@ -34,6 +34,11 @@ bld/
 # NUNIT
 *.VisualState.xml
 TestResult.xml
+csharp/tests/Facebook.Yoga/NUnit-[0-9\.]+/
+csharp/tests/Facebook.Yoga/YogaTest.dll
+csharp/tests/Facebook.Yoga/YogaTest.dll.mdb
+csharp/tests/Facebook.Yoga/libyoga.dylib
+csharp/tests/Facebook.Yoga/libyoga.dylib.dSYM/

 # Build Results of an ATL Project
 [Dd]ebugPS/
--- a/csharp/BUCK
+++ b/csharp/BUCK
@@ -6,15 +6,15 @@
 # of patent rights can be found in the PATENTS file in the same directory.

 csharp_library(
-  name = 'csslibnet46',
-  dll_name = 'Facebook.CSSLayout.dll',
+  name = 'yogalibnet46',
+  dll_name = 'Facebook.Yoga.dll',
  framework_ver = 'net46',
  srcs = glob(['**/*.cs']),
 )

 csharp_library(
-  name = 'csslibnet45',
-  dll_name = 'Facebook.CSSLayout.dll',
+  name = 'yogalibnet45',
+  dll_name = 'Facebook.Yoga.dll',
  framework_ver = 'net45',
  srcs = glob(['**/*.cs']),
 )
--- a/csharp/Facebook.CSSLayout/CSSAssert.cs
+++ b/csharp/Facebook.CSSLayout/CSSAssert.cs
@@ -1,35 +0,0 @@
-/**
- * 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.CSSLayout
-{
-    internal static class CSSAssert
-    {
-        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate void FailFunc(string message);
-
-        private static bool _assertInitialized;
-        private static FailFunc _failFunc;
-
-        public static void Initialize()
-        {
-            if (!_assertInitialized)
-            {
-                _failFunc = (message) => {
-                    throw new InvalidOperationException(message);
-                };
-                Native.CSSAssertSetFailFunc(_failFunc);
-                _assertInitialized = true;
-            }
-        }
-    }
-}
--- a/csharp/Facebook.CSSLayout/CSSNode.cs
+++ b/csharp/Facebook.CSSLayout/CSSNode.cs
@@ -1,567 +0,0 @@
-/**
- * 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.CSSLayout
-{
-    public class CSSNode : IEnumerable<CSSNode>
-    {
-        private IntPtr _cssNode;
-        private WeakReference _parent;
-        private List<CSSNode> _children;
-        private MeasureFunction _measureFunction;
-        private CSSMeasureFunc _cssMeasureFunc;
-        private object _data;
-
-        public CSSNode()
-        {
-            CSSAssert.Initialize();
-            CSSLogger.Initialize();
-
-            _cssNode = Native.CSSNodeNew();
-            if (_cssNode == IntPtr.Zero)
-            {
-                throw new InvalidOperationException("Failed to allocate native memory");
-            }
-        }
-
-        ~CSSNode()
-        {
-            Native.CSSNodeFree(_cssNode);
-        }
-
-        public void Reset()
-        {
-            _measureFunction = null;
-            _data = null;
-
-            Native.CSSNodeReset(_cssNode);
-        }
-
-        public bool IsDirty
-        {
-            get
-            {
-                return Native.CSSNodeIsDirty(_cssNode);
-            }
-        }
-
-        public virtual void MarkDirty()
-        {
-            Native.CSSNodeMarkDirty(_cssNode);
-        }
-
-        public bool IsTextNode
-        {
-            get
-            {
-                return Native.CSSNodeGetIsTextnode(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeSetIsTextnode(_cssNode, value);
-            }
-        }
-
-        public bool HasNewLayout
-        {
-            get
-            {
-                return Native.CSSNodeGetHasNewLayout(_cssNode);
-            }
-        }
-
-        public void MarkHasNewLayout()
-        {
-            Native.CSSNodeSetHasNewLayout(_cssNode, true);
-        }
-
-        public CSSNode Parent
-        {
-            get
-            {
-                return _parent != null ? _parent.Target as CSSNode : null;
-            }
-        }
-
-        public bool IsMeasureDefined
-        {
-            get
-            {
-                return _measureFunction != null;
-            }
-        }
-
-        public CSSDirection StyleDirection
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetDirection(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetDirection(_cssNode, value);
-            }
-        }
-
-        public CSSFlexDirection FlexDirection
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetFlexDirection(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetFlexDirection(_cssNode, value);
-            }
-        }
-
-        public CSSJustify JustifyContent
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetJustifyContent(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetJustifyContent(_cssNode, value);
-            }
-        }
-
-        public CSSAlign AlignItems
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetAlignItems(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetAlignItems(_cssNode, value);
-            }
-        }
-
-        public CSSAlign AlignSelf
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetAlignSelf(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetAlignSelf(_cssNode, value);
-            }
-        }
-
-        public CSSAlign AlignContent
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetAlignContent(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetAlignContent(_cssNode, value);
-            }
-        }
-
-        public CSSPositionType PositionType
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetPositionType(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetPositionType(_cssNode, value);
-            }
-        }
-
-        public CSSWrap Wrap
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetFlexWrap(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetFlexWrap(_cssNode, value);
-            }
-        }
-
-        public float Flex
-        {
-            set
-            {
-                Native.CSSNodeStyleSetFlex(_cssNode, value);
-            }
-        }
-
-        public float FlexGrow
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetFlexGrow(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetFlexGrow(_cssNode, value);
-            }
-        }
-
-        public float FlexShrink
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetFlexShrink(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetFlexShrink(_cssNode, value);
-            }
-        }
-
-        public float FlexBasis
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetFlexBasis(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetFlexBasis(_cssNode, value);
-            }
-        }
-
-        public float GetMargin(CSSEdge edge)
-        {
-            return Native.CSSNodeStyleGetMargin(_cssNode, edge);
-        }
-
-        public void SetMargin(CSSEdge edge, float value)
-        {
-            Native.CSSNodeStyleSetMargin(_cssNode, edge, value);
-        }
-
-        public float GetPadding(CSSEdge edge)
-        {
-            return Native.CSSNodeStyleGetPadding(_cssNode, edge);
-        }
-
-        public void SetPadding(CSSEdge edge, float padding)
-        {
-            Native.CSSNodeStyleSetPadding(_cssNode, edge, padding);
-        }
-
-        public float GetBorder(CSSEdge edge)
-        {
-            return Native.CSSNodeStyleGetBorder(_cssNode, edge);
-        }
-
-        public void SetBorder(CSSEdge edge, float border)
-        {
-            Native.CSSNodeStyleSetBorder(_cssNode, edge, border);
-        }
-
-        public float GetPosition(CSSEdge edge)
-        {
-            return Native.CSSNodeStyleGetPosition(_cssNode, edge);
-        }
-
-        public void SetPosition(CSSEdge edge, float position)
-        {
-            Native.CSSNodeStyleSetPosition(_cssNode, edge, position);
-        }
-
-        public float StyleWidth
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetWidth(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetWidth(_cssNode, value);
-            }
-        }
-
-        public float StyleHeight
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetHeight(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetHeight(_cssNode, value);
-            }
-        }
-
-        public float StyleMaxWidth
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetMaxWidth(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetMaxWidth(_cssNode, value);
-            }
-        }
-
-        public float StyleMaxHeight
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetMaxHeight(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetMaxHeight(_cssNode, value);
-            }
-        }
-
-        public float StyleMinWidth
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetMinWidth(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetMinWidth(_cssNode, value);
-            }
-        }
-
-        public float StyleMinHeight
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetMinHeight(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetMinHeight(_cssNode, value);
-            }
-        }
-
-        public float LayoutX
-        {
-            get
-            {
-                return Native.CSSNodeLayoutGetLeft(_cssNode);
-            }
-        }
-
-        public float LayoutY
-        {
-            get
-            {
-                return Native.CSSNodeLayoutGetTop(_cssNode);
-            }
-        }
-
-        public float LayoutWidth
-        {
-            get
-            {
-                return Native.CSSNodeLayoutGetWidth(_cssNode);
-            }
-        }
-
-        public float LayoutHeight
-        {
-            get
-            {
-                return Native.CSSNodeLayoutGetHeight(_cssNode);
-            }
-        }
-
-        public CSSDirection LayoutDirection
-        {
-            get
-            {
-                return Native.CSSNodeLayoutGetDirection(_cssNode);
-            }
-        }
-
-        public CSSOverflow Overflow
-        {
-            get
-            {
-                return Native.CSSNodeStyleGetOverflow(_cssNode);
-            }
-
-            set
-            {
-                Native.CSSNodeStyleSetOverflow(_cssNode, value);
-            }
-        }
-
-        public object Data
-        {
-            get
-            {
-                return _data;
-            }
-
-            set
-            {
-                _data = value;
-            }
-        }
-
-        public CSSNode this[int index]
-        {
-            get
-            {
-                return _children[index];
-            }
-        }
-
-        public int Count
-        {
-            get
-            {
-                return _children != null ? _children.Count : 0;
-            }
-        }
-
-        public void MarkLayoutSeen()
-        {
-            Native.CSSNodeSetHasNewLayout(_cssNode, 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, CSSNode node)
-        {
-            if (_children == null)
-            {
-                _children = new List<CSSNode>(4);
-            }
-            _children.Insert(index, node);
-            node._parent = new WeakReference(this);
-            Native.CSSNodeInsertChild(_cssNode, node._cssNode, (uint)index);
-        }
-
-        public void RemoveAt(int index)
-        {
-            var child = _children[index];
-            child._parent = null;
-            _children.RemoveAt(index);
-            Native.CSSNodeRemoveChild(_cssNode, child._cssNode);
-        }
-
-        public void Clear()
-        {
-            if (_children != null)
-            {
-                while (_children.Count > 0)
-                {
-                    RemoveAt(_children.Count-1);
-                }
-            }
-        }
-
-        public int IndexOf(CSSNode node)
-        {
-            return _children != null ? _children.IndexOf(node) : -1;
-        }
-
-        public void SetMeasureFunction(MeasureFunction measureFunction)
-        {
-            _measureFunction = measureFunction;
-            _cssMeasureFunc = measureFunction != null ? MeasureInternal : (CSSMeasureFunc)null;
-            Native.CSSNodeSetMeasureFunc(_cssNode, _cssMeasureFunc);
-        }
-
-        public void CalculateLayout()
-        {
-            Native.CSSNodeCalculateLayout(
-                _cssNode,
-                CSSConstants.Undefined,
-                CSSConstants.Undefined,
-                Native.CSSNodeStyleGetDirection(_cssNode));
-        }
-
-        private CSSSize MeasureInternal(
-            IntPtr node,
-            float width,
-            CSSMeasureMode widthMode,
-            float height,
-            CSSMeasureMode heightMode)
-        {
-            if (_measureFunction == null)
-            {
-                throw new InvalidOperationException("Measure function is not defined.");
-            }
-
-            long output = _measureFunction(this, width, widthMode, height, heightMode);
-            return new CSSSize { width = MeasureOutput.GetWidth(output), height = MeasureOutput.GetHeight(output) };
-        }
-
-        public string Print(CSSPrintOptions options =
-            CSSPrintOptions.Layout|CSSPrintOptions.Style|CSSPrintOptions.Children)
-        {
-            StringBuilder sb = new StringBuilder();
-            CSSLogger.Logger = (message) => {sb.Append(message);};
-            Native.CSSNodePrint(_cssNode, options);
-            CSSLogger.Logger = null;
-            return sb.ToString();
-        }
-
-        public IEnumerator<CSSNode> GetEnumerator()
-        {
-            return _children != null ? ((IEnumerable<CSSNode>)_children).GetEnumerator() :
-                System.Linq.Enumerable.Empty<CSSNode>().GetEnumerator();
-        }
-
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return _children != null ? ((IEnumerable<CSSNode>)_children).GetEnumerator() :
-                System.Linq.Enumerable.Empty<CSSNode>().GetEnumerator();
-        }
-
-        public static int GetInstanceCount()
-        {
-            return Native.CSSNodeGetInstanceCount();
-        }
-    }
-}
--- a/csharp/Facebook.CSSLayout/Native.cs
+++ b/csharp/Facebook.CSSLayout/Native.cs
@@ -1,279 +0,0 @@
-/**
- * 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.CSSLayout
-{
-    internal static class Native
-    {
-#if UNITY_IOS && !UNITY_EDITOR
-        private const string DllName = "__Internal";
-#else
-        private const string DllName = "CSSLayout";
-#endif
-
-        [DllImport(DllName)]
-        public static extern void CSSInteropSetLogger(
-            [MarshalAs(UnmanagedType.FunctionPtr)] CSSLogger.Func func);
-
-        [DllImport(DllName)]
-        public static extern void CSSAssertSetFailFunc(
-            [MarshalAs(UnmanagedType.FunctionPtr)] CSSAssert.FailFunc func);
-
-        [DllImport(DllName)]
-        public static extern IntPtr CSSNodeNew();
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeInit(IntPtr cssNode);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeFree(IntPtr cssNode);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeReset(IntPtr cssNode);
-
-        [DllImport(DllName)]
-        public static extern int CSSNodeGetInstanceCount();
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeInsertChild(IntPtr node, IntPtr child, uint index);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeRemoveChild(IntPtr node, IntPtr child);
-
-        [DllImport(DllName)]
-        public static extern IntPtr CSSNodeGetChild(IntPtr node, uint index);
-
-        [DllImport(DllName)]
-        public static extern uint CSSNodeChildCount(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeCalculateLayout(IntPtr node,
-                            float availableWidth,
-                            float availableHeight,
-                            CSSDirection parentDirection);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeMarkDirty(IntPtr node);
-
-        [DllImport(DllName)]
-        [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool CSSNodeIsDirty(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodePrint(IntPtr node, CSSPrintOptions options);
-
-        [DllImport(DllName)]
-        [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool CSSValueIsUndefined(float value);
-
-        #region CSS_NODE_PROPERTY
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeSetContext(IntPtr node, IntPtr context);
-
-        [DllImport(DllName)]
-        public static extern IntPtr CSSNodeGetContext(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeSetMeasureFunc(
-            IntPtr node,
-            [MarshalAs(UnmanagedType.FunctionPtr)] CSSMeasureFunc measureFunc);
-
-        [DllImport(DllName)]
-        [return: MarshalAs(UnmanagedType.FunctionPtr)]
-        public static extern CSSMeasureFunc CSSNodeGetMeasureFunc(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeSetIsTextnode(IntPtr node, [MarshalAs(UnmanagedType.I1)] bool isTextNode);
-
-        [DllImport(DllName)]
-        [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool CSSNodeGetIsTextnode(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeSetHasNewLayout(IntPtr node, [MarshalAs(UnmanagedType.I1)] bool hasNewLayout);
-
-        [DllImport(DllName)]
-        [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool CSSNodeGetHasNewLayout(IntPtr node);
-
-        #endregion
-
-        #region CSS_NODE_STYLE_PROPERTY
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetDirection(IntPtr node, CSSDirection direction);
-
-        [DllImport(DllName)]
-        public static extern CSSDirection CSSNodeStyleGetDirection(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetFlexDirection(IntPtr node, CSSFlexDirection flexDirection);
-
-        [DllImport(DllName)]
-        public static extern CSSFlexDirection CSSNodeStyleGetFlexDirection(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetJustifyContent(IntPtr node, CSSJustify justifyContent);
-
-        [DllImport(DllName)]
-        public static extern CSSJustify CSSNodeStyleGetJustifyContent(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetAlignContent(IntPtr node, CSSAlign alignContent);
-
-        [DllImport(DllName)]
-        public static extern CSSAlign CSSNodeStyleGetAlignContent(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetAlignItems(IntPtr node, CSSAlign alignItems);
-
-        [DllImport(DllName)]
-        public static extern CSSAlign CSSNodeStyleGetAlignItems(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetAlignSelf(IntPtr node, CSSAlign alignSelf);
-
-        [DllImport(DllName)]
-        public static extern CSSAlign CSSNodeStyleGetAlignSelf(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetPositionType(IntPtr node, CSSPositionType positionType);
-
-        [DllImport(DllName)]
-        public static extern CSSPositionType CSSNodeStyleGetPositionType(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetFlexWrap(IntPtr node, CSSWrap flexWrap);
-
-        [DllImport(DllName)]
-        public static extern CSSWrap CSSNodeStyleGetFlexWrap(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetOverflow(IntPtr node, CSSOverflow flexWrap);
-
-        [DllImport(DllName)]
-        public static extern CSSOverflow CSSNodeStyleGetOverflow(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetFlex(IntPtr node, float flex);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetFlexGrow(IntPtr node, float flexGrow);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetFlexGrow(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetFlexShrink(IntPtr node, float flexShrink);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetFlexShrink(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetFlexBasis(IntPtr node, float flexBasis);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetFlexBasis(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetWidth(IntPtr node, float width);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetWidth(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetHeight(IntPtr node, float height);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetHeight(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetMinWidth(IntPtr node, float minWidth);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetMinWidth(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetMinHeight(IntPtr node, float minHeight);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetMinHeight(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetMaxWidth(IntPtr node, float maxWidth);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetMaxWidth(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetMaxHeight(IntPtr node, float maxHeight);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetMaxHeight(IntPtr node);
-
-        #endregion
-
-        #region CSS_NODE_STYLE_EDGE_PROPERTY
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetPosition(IntPtr node, CSSEdge edge, float position);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetPosition(IntPtr node, CSSEdge edge);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetMargin(IntPtr node, CSSEdge edge, float margin);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetMargin(IntPtr node, CSSEdge edge);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetPadding(IntPtr node, CSSEdge edge, float padding);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetPadding(IntPtr node, CSSEdge edge);
-
-        [DllImport(DllName)]
-        public static extern void CSSNodeStyleSetBorder(IntPtr node, CSSEdge edge, float border);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeStyleGetBorder(IntPtr node, CSSEdge edge);
-
-        #endregion
-
-        #region CSS_NODE_LAYOUT_PROPERTY
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeLayoutGetLeft(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeLayoutGetTop(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeLayoutGetRight(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeLayoutGetBottom(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeLayoutGetWidth(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern float CSSNodeLayoutGetHeight(IntPtr node);
-
-        [DllImport(DllName)]
-        public static extern CSSDirection CSSNodeLayoutGetDirection(IntPtr node);
-
-        #endregion
-    }
-}
--- a/csharp/Facebook.CSSLayout.sln
+++ b/csharp/Facebook.CSSLayout.sln
@@ -3,9 +3,9 @@ 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}") = "CSSLayout", "CSSLayout\CSSLayout.vcxproj", "{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Yoga", "Yoga\Yoga.vcxproj", "{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}"
 EndProject
-Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Facebook.CSSLayout", "Facebook.CSSLayout\Facebook.CSSLayout.xproj", "{75BB7605-E54B-4EDE-8F5A-FF1F24464236}"
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Facebook.Yoga", "Facebook.Yoga\Facebook.Yoga.xproj", "{75BB7605-E54B-4EDE-8F5A-FF1F24464236}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
--- a/csharp/Facebook.CSSLayout/Facebook.CSSLayout.xproj
+++ b/csharp/Facebook.CSSLayout/Facebook.CSSLayout.xproj
@@ -8,7 +8,7 @@
  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.Props" Condition="'$(VSToolsPath)' != ''" />
  <PropertyGroup Label="Globals">
    <ProjectGuid>75bb7605-e54b-4ede-8f5a-ff1f24464236</ProjectGuid>
-    <RootNamespace>Facebook.CSSLayout</RootNamespace>
+    <RootNamespace>Facebook.Yoga</RootNamespace>
    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">.\obj</BaseIntermediateOutputPath>
    <OutputPath Condition="'$(OutputPath)'=='' ">.\bin\</OutputPath>
    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
--- a/csharp/Facebook.CSSLayout/MeasureFunction.cs
+++ b/csharp/Facebook.CSSLayout/MeasureFunction.cs
@@ -7,12 +7,12 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
    public delegate long MeasureFunction(
-      CSSNode node,
+        YogaNode node,
        float width,
-      CSSMeasureMode widthMode,
+        YogaMeasureMode widthMode,
        float height,
-      CSSMeasureMode heightMode);
+        YogaMeasureMode heightMode);
 }
--- a/csharp/Facebook.CSSLayout/MeasureOutput.cs
+++ b/csharp/Facebook.CSSLayout/MeasureOutput.cs
@@ -7,13 +7,18 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+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 | ((ulong) height));
+            return (long)(((ulong) width) << 32 | ((uint) height));
        }

        public static int GetWidth(long measureOutput)
--- a/csharp/Facebook.Yoga/Native.cs
+++ b/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 node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeFree(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void YGNodeReset(IntPtr node);
+
+        [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
+    }
+}
--- a/csharp/Facebook.CSSLayout/Properties/AssemblyInfo.cs
+++ b/csharp/Facebook.CSSLayout/Properties/AssemblyInfo.cs
@@ -16,7 +16,7 @@ using System.Runtime.InteropServices;
 // associated with an assembly.
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("Facebook, Inc.")]
-[assembly: AssemblyProduct("Facebook.CSSLayout")]
+[assembly: AssemblyProduct("Facebook.Yoga")]
 [assembly: AssemblyTrademark("Copyright (c) 2014-present, Facebook, Inc.")]

 // Setting ComVisible to false makes the types in this assembly not visible
--- a/csharp/Facebook.Yoga/Spacing.cs
+++ b/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;
+        }
+    }
+}
--- a/csharp/Facebook.CSSLayout/CSSAlign.cs
+++ b/csharp/Facebook.CSSLayout/CSSAlign.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,14 +7,14 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSAlign
+    public enum YogaAlign
    {
        Auto,
        FlexStart,
        Center,
        FlexEnd,
-        Stretch
+        Stretch,
    }
 }
--- a/csharp/Facebook.CSSLayout/CSSConstants.cs
+++ b/csharp/Facebook.CSSLayout/CSSConstants.cs
@@ -7,9 +7,9 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public static class CSSConstants
+    public static class YogaConstants
    {
        public const float Undefined = float.NaN;

--- a/csharp/Facebook.CSSLayout/CSSDimension.cs
+++ b/csharp/Facebook.CSSLayout/CSSDimension.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,11 +7,11 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSDimension
+    public enum YogaDimension
    {
        Width,
-        Height
+        Height,
    }
 }
--- a/csharp/Facebook.CSSLayout/CSSDIrection.cs
+++ b/csharp/Facebook.CSSLayout/CSSDIrection.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,12 +7,12 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSDirection
+    public enum YogaDirection
    {
        Inherit,
-        LeftToRight,
-        RightToLeft
+        LTR,
+        RTL,
    }
 }
--- a/csharp/Facebook.CSSLayout/CSSEdge.cs
+++ b/csharp/Facebook.CSSLayout/CSSEdge.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,9 +7,9 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSEdge
+    public enum YogaEdge
    {
        Left,
        Top,
@@ -20,6 +20,5 @@ namespace Facebook.CSSLayout
        Horizontal,
        Vertical,
        All,
-        Count,
    }
 }
--- a/csharp/Facebook.Yoga/YogaExperimentalFeature.cs
+++ b/csharp/Facebook.Yoga/YogaExperimentalFeature.cs
@@ -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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaExperimentalFeature
+    {
+        Rounding,
+        WebFlexBasis,
+    }
+}
--- a/csharp/Facebook.CSSLayout/CSSFlexDirection.cs
+++ b/csharp/Facebook.CSSLayout/CSSFlexDirection.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,9 +7,9 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSFlexDirection
+    public enum YogaFlexDirection
    {
        Column,
        ColumnReverse,
--- a/csharp/Facebook.CSSLayout/CSSJustify.cs
+++ b/csharp/Facebook.CSSLayout/CSSJustify.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,9 +7,9 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSJustify
+    public enum YogaJustify
    {
        FlexStart,
        Center,
--- a/csharp/Facebook.Yoga/YogaLogLevel.cs
+++ b/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,
+    }
+}
--- a/csharp/Facebook.CSSLayout/CSSLogger.cs
+++ b/csharp/Facebook.CSSLayout/CSSLogger.cs
@@ -10,12 +10,12 @@
 using System;
 using System.Runtime.InteropServices;

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    internal static class CSSLogger
+    internal static class YogaLogger
    {
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate void Func(string message);
+        public delegate void Func(YogaLogLevel level, string message);

        private static bool _initialized;
        private static Func _managedLogger = null;
@@ -26,13 +26,18 @@ namespace Facebook.CSSLayout
        {
            if (!_initialized)
            {
-                _managedLogger = (message) => {
+                _managedLogger = (level, message) => {
                    if (Logger != null)
                    {
-                        Logger(message);
+                        Logger(level, message);
+                    }
+
+                    if (level == YogaLogLevel.Error)
+                    {
+                        throw new InvalidOperationException(message);
                    }
                };
-                Native.CSSInteropSetLogger(_managedLogger);
+                Native.YGInteropSetLogger(_managedLogger);
                _initialized = true;
            }
        }
--- a/csharp/Facebook.CSSLayout/CSSMeasureFunc.cs
+++ b/csharp/Facebook.CSSLayout/CSSMeasureFunc.cs
@@ -10,13 +10,13 @@
 using System;
 using System.Runtime.InteropServices;

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-    public delegate CSSSize CSSMeasureFunc(
+    public delegate YogaSize YogaMeasureFunc(
        IntPtr node,
        float width,
-        CSSMeasureMode widthMode,
+        YogaMeasureMode widthMode,
        float height,
-        CSSMeasureMode heightMode);
+        YogaMeasureMode heightMode);
 }
--- a/csharp/Facebook.CSSLayout/CSSMeasureMode.cs
+++ b/csharp/Facebook.CSSLayout/CSSMeasureMode.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,13 +7,12 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSMeasureMode
+    public enum YogaMeasureMode
    {
        Undefined,
        Exactly,
        AtMost,
-        Count,
    }
 }
--- a/csharp/Facebook.Yoga/YogaNode.Create.cs
+++ b/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;
+        }
+    }
+}
--- a/csharp/Facebook.Yoga/YogaNode.cs
+++ b/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);
+        }
+    }
+}
--- a/csharp/Facebook.CSSLayout/CSSOverflow.cs
+++ b/csharp/Facebook.CSSLayout/CSSOverflow.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,11 +7,12 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSOverflow
+    public enum YogaOverflow
    {
        Visible,
        Hidden,
+        Scroll,
    }
 }
--- a/csharp/Facebook.CSSLayout/CSSPositionType.cs
+++ b/csharp/Facebook.CSSLayout/CSSPositionType.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,11 +7,11 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSPositionType
+    public enum YogaPositionType
    {
        Relative,
-        Absolute
+        Absolute,
    }
 }
--- a/csharp/Facebook.CSSLayout/CSSPrintOptions.cs
+++ b/csharp/Facebook.CSSLayout/CSSPrintOptions.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,9 +7,9 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSPrintOptions
+    public enum YogaPrintOptions
    {
        Layout = 1,
        Style = 2,
--- a/csharp/Facebook.CSSLayout/CSSSize.cs
+++ b/csharp/Facebook.CSSLayout/CSSSize.cs
@@ -9,10 +9,10 @@

 using System.Runtime.InteropServices;

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
    [StructLayout(LayoutKind.Sequential)]
-    public struct CSSSize
+    public struct YogaSize
    {
        public float width;
        public float height;
--- a/csharp/Facebook.CSSLayout/CSSWrap.cs
+++ b/csharp/Facebook.CSSLayout/CSSWrap.cs
@@ -1,4 +1,4 @@
-/**
+/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 *
@@ -7,9 +7,9 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
-    public enum CSSWrap
+    public enum YogaWrap
    {
        NoWrap,
        Wrap,
--- a/csharp/Facebook.CSSLayout/project.json
+++ b/csharp/Facebook.CSSLayout/project.json
--- a/csharp/CSSLayout/CSSInterop.cpp
+++ b/csharp/CSSLayout/CSSInterop.cpp
@@ -7,24 +7,21 @@
 * of patent rights can be found in the PATENTS file in the same directory.
 */

-#include "CSSInterop.h"
+#include "YGInterop.h"

-static CSSInteropLoggerFunc gManagedFunc;
+static YGInteropLoggerFunc gManagedFunc;

-static int unmanagedLogger(const char *format, ...) {
+static int unmanagedLogger(YGLogLevel level, const char *format, va_list args) {
  int result = 0;
  if (gManagedFunc) {
-    va_list args;
-    va_start(args, format);
    char buffer[256];
    result = vsnprintf(buffer, sizeof(buffer), format, args);
-    (*gManagedFunc)(buffer);
-    va_end(args);
+    (*gManagedFunc)(level, buffer);
  }
  return result;
 }

-void CSSInteropSetLogger(CSSInteropLoggerFunc managedFunc) {
+void YGInteropSetLogger(YGInteropLoggerFunc managedFunc) {
  gManagedFunc = managedFunc;
-  CSSLayoutSetLogger(&unmanagedLogger);
+  YGSetLogger(&unmanagedLogger);
 }
--- a/csharp/CSSLayout/CSSInterop.h
+++ b/csharp/CSSLayout/CSSInterop.h
@@ -9,12 +9,12 @@

 #pragma once

-#include <CSSLayout/CSSLayout.h>
+#include <yoga/Yoga.h>

-CSS_EXTERN_C_BEGIN
+YG_EXTERN_C_BEGIN

-typedef void (*CSSInteropLoggerFunc)(const char *message);
+typedef void (*YGInteropLoggerFunc)(YGLogLevel level, const char *message);

-WIN_EXPORT void CSSInteropSetLogger(CSSInteropLoggerFunc managedFunc);
+WIN_EXPORT void YGInteropSetLogger(YGInteropLoggerFunc managedFunc);

-CSS_EXTERN_C_END
+YG_EXTERN_C_END
--- a/csharp/CSSLayout/CSSLayout.vcxproj
+++ b/csharp/CSSLayout/CSSLayout.vcxproj
@@ -21,7 +21,7 @@
  <PropertyGroup Label="Globals">
    <ProjectGuid>{0446C86B-F47B-4C46-B673-C7AE0CFF35D5}</ProjectGuid>
    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>CSSLayout</RootNamespace>
+    <RootNamespace>Yoga</RootNamespace>
    <WindowsTargetPlatformVersion>10.0.14393.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
@@ -87,7 +87,7 @@
      </PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;CSSLAYOUT_EXPORTS;CSS_ASSERT_FAIL_ENABLED;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;YOGA_EXPORTS;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <SDLCheck>true</SDLCheck>
      <AdditionalIncludeDirectories>$(ProjectDir)..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
@@ -102,7 +102,7 @@
      </PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;CSSLAYOUT_EXPORTS;CSS_ASSERT_FAIL_ENABLED;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;YOGA_EXPORTS;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <SDLCheck>true</SDLCheck>
      <AdditionalIncludeDirectories>$(ProjectDir)..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
@@ -119,7 +119,7 @@
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;CSSLAYOUT_EXPORTS;CSS_ASSERT_FAIL_ENABLED;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;YOGA_EXPORTS;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <SDLCheck>true</SDLCheck>
      <AdditionalIncludeDirectories>$(ProjectDir)..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
@@ -138,7 +138,7 @@
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;CSSLAYOUT_EXPORTS;CSS_ASSERT_FAIL_ENABLED;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;YOGA_EXPORTS;FB_ASSERTIONS_ENABLED=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <SDLCheck>true</SDLCheck>
      <AdditionalIncludeDirectories>$(ProjectDir)..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
@@ -150,17 +150,17 @@
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
-    <ClInclude Include="..\..\CSSLayout\CSSLayout.h" />
-    <ClInclude Include="..\..\CSSLayout\CSSMacros.h" />
-    <ClInclude Include="..\..\CSSLayout\CSSNodeList.h" />
-    <ClInclude Include="CSSInterop.h" />
+    <ClInclude Include="..\..\yoga\Yoga.h" />
+    <ClInclude Include="..\..\yoga\YGMacros.h" />
+    <ClInclude Include="..\..\yoga\YGNodeList.h" />
+    <ClInclude Include="YGInterop.h" />
    <ClInclude Include="stdafx.h" />
    <ClInclude Include="targetver.h" />
  </ItemGroup>
  <ItemGroup>
-    <ClCompile Include="..\..\CSSLayout\CSSLayout.c" />
-    <ClCompile Include="..\..\CSSLayout\CSSNodeList.c" />
-    <ClCompile Include="CSSInterop.cpp" />
+    <ClCompile Include="..\..\yoga\Yoga.c" />
+    <ClCompile Include="..\..\yoga\YGNodeList.c" />
+    <ClCompile Include="YGInterop.cpp" />
    <ClCompile Include="dllmain.cpp">
      <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</CompileAsManaged>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
--- a/csharp/CSSLayout/CSSLayout.vcxproj.filters
+++ b/csharp/CSSLayout/CSSLayout.vcxproj.filters
@@ -21,16 +21,16 @@
    <ClInclude Include="targetver.h">
      <Filter>Header Files</Filter>
    </ClInclude>
-    <ClInclude Include="..\..\CSSLayout\CSSLayout.h">
+    <ClInclude Include="..\..\yoga\Yoga.h">
      <Filter>Header Files</Filter>
    </ClInclude>
-    <ClInclude Include="..\..\CSSLayout\CSSMacros.h">
+    <ClInclude Include="..\..\yoga\YGMacros.h">
      <Filter>Header Files</Filter>
    </ClInclude>
-    <ClInclude Include="..\..\CSSLayout\CSSNodeList.h">
+    <ClInclude Include="..\..\yoga\YGNodeList.h">
      <Filter>Header Files</Filter>
    </ClInclude>
-    <ClInclude Include="CSSInterop.h">
+    <ClInclude Include="YGInterop.h">
      <Filter>Header Files</Filter>
    </ClInclude>
  </ItemGroup>
@@ -41,13 +41,13 @@
    <ClCompile Include="dllmain.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="..\..\CSSLayout\CSSLayout.c">
+    <ClCompile Include="..\..\yoga\Yoga.c">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="..\..\CSSLayout\CSSNodeList.c">
+    <ClCompile Include="..\..\yoga\YGNodeList.c">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="CSSInterop.cpp">
+    <ClCompile Include="YGInterop.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
  </ItemGroup>
--- a/csharp/CSSLayout/dllmain.cpp
+++ b/csharp/CSSLayout/dllmain.cpp
--- a/csharp/CSSLayout/stdafx.cpp
+++ b/csharp/CSSLayout/stdafx.cpp
@@ -8,7 +8,7 @@
 */

 // stdafx.cpp : source file that includes just the standard includes
-// CSSLayout.pch will be the pre-compiled header
+// Yoga.pch will be the pre-compiled header
 // stdafx.obj will contain the pre-compiled type information

 #include "stdafx.h"
--- a/csharp/CSSLayout/stdafx.h
+++ b/csharp/CSSLayout/stdafx.h
--- a/csharp/CSSLayout/targetver.h
+++ b/csharp/CSSLayout/targetver.h
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutAbsolutePositionTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutAbsolutePositionTest.cs
@@ -1,266 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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: 0; top: 0;">
-    <div style="width: 100px; height: 100px;"></div>
-  </div>
-</div>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutAbsolutePositionTest
-    {
-        [Test]
-        public void Test_absolute_layout_width_height_start_top()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.PositionType = CSSPositionType.Absolute;
-            root_child0.SetPosition(CSSEdge.Start, 10);
-            root_child0.SetPosition(CSSEdge.Top, 10);
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(80, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_absolute_layout_width_height_end_bottom()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.PositionType = CSSPositionType.Absolute;
-            root_child0.SetPosition(CSSEdge.End, 10);
-            root_child0.SetPosition(CSSEdge.Bottom, 10);
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(80, root_child0.LayoutX);
-            Assert.AreEqual(80, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(80, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_absolute_layout_start_top_end_bottom()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.PositionType = CSSPositionType.Absolute;
-            root_child0.SetPosition(CSSEdge.Start, 10);
-            root_child0.SetPosition(CSSEdge.Top, 10);
-            root_child0.SetPosition(CSSEdge.End, 10);
-            root_child0.SetPosition(CSSEdge.Bottom, 10);
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(80, root_child0.LayoutWidth);
-            Assert.AreEqual(80, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(80, root_child0.LayoutWidth);
-            Assert.AreEqual(80, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_absolute_layout_width_height_start_top_end_bottom()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.PositionType = CSSPositionType.Absolute;
-            root_child0.SetPosition(CSSEdge.Start, 10);
-            root_child0.SetPosition(CSSEdge.Top, 10);
-            root_child0.SetPosition(CSSEdge.End, 10);
-            root_child0.SetPosition(CSSEdge.Bottom, 10);
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(80, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_do_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hidden_parent()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.Overflow = CSSOverflow.Hidden;
-            root.StyleWidth = 50;
-            root.StyleHeight = 50;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.PositionType = CSSPositionType.Absolute;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child0_child0 = new CSSNode();
-            root_child0_child0.StyleWidth = 100;
-            root_child0_child0.StyleHeight = 100;
-            root_child0.Insert(0, root_child0_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(50, root.LayoutWidth);
-            Assert.AreEqual(50, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0_child0.LayoutX);
-            Assert.AreEqual(0, root_child0_child0.LayoutY);
-            Assert.AreEqual(100, root_child0_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(50, root.LayoutWidth);
-            Assert.AreEqual(50, root.LayoutHeight);
-
-            Assert.AreEqual(-50, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0_child0.LayoutX);
-            Assert.AreEqual(0, root_child0_child0.LayoutY);
-            Assert.AreEqual(100, root_child0_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0_child0.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutAlignContentTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutAlignContentTest.cs
@@ -1,450 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutAlignContentTest
-    {
-        [Test]
-        public void Test_align_content_flex_start()
-        {
-            CSSNode root = new CSSNode();
-            root.Wrap = CSSWrap.Wrap;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 50;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 50;
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 50;
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-
-            CSSNode root_child3 = new CSSNode();
-            root_child3.StyleWidth = 50;
-            root_child3.StyleHeight = 10;
-            root.Insert(3, root_child3);
-
-            CSSNode root_child4 = new CSSNode();
-            root_child4.StyleWidth = 50;
-            root_child4.StyleHeight = 10;
-            root.Insert(4, root_child4);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(20, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            Assert.AreEqual(0, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(50, root_child3.LayoutWidth);
-            Assert.AreEqual(10, root_child3.LayoutHeight);
-
-            Assert.AreEqual(0, root_child4.LayoutX);
-            Assert.AreEqual(40, root_child4.LayoutY);
-            Assert.AreEqual(50, root_child4.LayoutWidth);
-            Assert.AreEqual(10, root_child4.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(50, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(50, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(50, root_child2.LayoutX);
-            Assert.AreEqual(20, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            Assert.AreEqual(50, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(50, root_child3.LayoutWidth);
-            Assert.AreEqual(10, root_child3.LayoutHeight);
-
-            Assert.AreEqual(50, root_child4.LayoutX);
-            Assert.AreEqual(40, root_child4.LayoutY);
-            Assert.AreEqual(50, root_child4.LayoutWidth);
-            Assert.AreEqual(10, root_child4.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_align_content_flex_end()
-        {
-            CSSNode root = new CSSNode();
-            root.AlignContent = CSSAlign.FlexEnd;
-            root.Wrap = CSSWrap.Wrap;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 50;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 50;
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 50;
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-
-            CSSNode root_child3 = new CSSNode();
-            root_child3.StyleWidth = 50;
-            root_child3.StyleHeight = 10;
-            root.Insert(3, root_child3);
-
-            CSSNode root_child4 = new CSSNode();
-            root_child4.StyleWidth = 50;
-            root_child4.StyleHeight = 10;
-            root.Insert(4, root_child4);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(20, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            Assert.AreEqual(0, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(50, root_child3.LayoutWidth);
-            Assert.AreEqual(10, root_child3.LayoutHeight);
-
-            Assert.AreEqual(0, root_child4.LayoutX);
-            Assert.AreEqual(40, root_child4.LayoutY);
-            Assert.AreEqual(50, root_child4.LayoutWidth);
-            Assert.AreEqual(10, root_child4.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(50, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(50, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(50, root_child2.LayoutX);
-            Assert.AreEqual(20, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            Assert.AreEqual(50, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(50, root_child3.LayoutWidth);
-            Assert.AreEqual(10, root_child3.LayoutHeight);
-
-            Assert.AreEqual(50, root_child4.LayoutX);
-            Assert.AreEqual(40, root_child4.LayoutY);
-            Assert.AreEqual(50, root_child4.LayoutWidth);
-            Assert.AreEqual(10, root_child4.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_align_content_center()
-        {
-            CSSNode root = new CSSNode();
-            root.AlignContent = CSSAlign.Center;
-            root.Wrap = CSSWrap.Wrap;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 50;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 50;
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 50;
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-
-            CSSNode root_child3 = new CSSNode();
-            root_child3.StyleWidth = 50;
-            root_child3.StyleHeight = 10;
-            root.Insert(3, root_child3);
-
-            CSSNode root_child4 = new CSSNode();
-            root_child4.StyleWidth = 50;
-            root_child4.StyleHeight = 10;
-            root.Insert(4, root_child4);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(20, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            Assert.AreEqual(0, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(50, root_child3.LayoutWidth);
-            Assert.AreEqual(10, root_child3.LayoutHeight);
-
-            Assert.AreEqual(0, root_child4.LayoutX);
-            Assert.AreEqual(40, root_child4.LayoutY);
-            Assert.AreEqual(50, root_child4.LayoutWidth);
-            Assert.AreEqual(10, root_child4.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(50, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(50, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(50, root_child2.LayoutX);
-            Assert.AreEqual(20, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            Assert.AreEqual(50, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(50, root_child3.LayoutWidth);
-            Assert.AreEqual(10, root_child3.LayoutHeight);
-
-            Assert.AreEqual(50, root_child4.LayoutX);
-            Assert.AreEqual(40, root_child4.LayoutY);
-            Assert.AreEqual(50, root_child4.LayoutWidth);
-            Assert.AreEqual(10, root_child4.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_align_content_stretch()
-        {
-            CSSNode root = new CSSNode();
-            root.AlignContent = CSSAlign.Stretch;
-            root.Wrap = CSSWrap.Wrap;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 50;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 50;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 50;
-            root.Insert(2, root_child2);
-
-            CSSNode root_child3 = new CSSNode();
-            root_child3.StyleWidth = 50;
-            root.Insert(3, root_child3);
-
-            CSSNode root_child4 = new CSSNode();
-            root_child4.StyleWidth = 50;
-            root.Insert(4, root_child4);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(0, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(0, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(0, root_child2.LayoutHeight);
-
-            Assert.AreEqual(0, root_child3.LayoutX);
-            Assert.AreEqual(0, root_child3.LayoutY);
-            Assert.AreEqual(50, root_child3.LayoutWidth);
-            Assert.AreEqual(0, root_child3.LayoutHeight);
-
-            Assert.AreEqual(0, root_child4.LayoutX);
-            Assert.AreEqual(0, root_child4.LayoutY);
-            Assert.AreEqual(50, root_child4.LayoutWidth);
-            Assert.AreEqual(0, root_child4.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(50, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(0, root_child0.LayoutHeight);
-
-            Assert.AreEqual(50, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(0, root_child1.LayoutHeight);
-
-            Assert.AreEqual(50, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(0, root_child2.LayoutHeight);
-
-            Assert.AreEqual(50, root_child3.LayoutX);
-            Assert.AreEqual(0, root_child3.LayoutY);
-            Assert.AreEqual(50, root_child3.LayoutWidth);
-            Assert.AreEqual(0, root_child3.LayoutHeight);
-
-            Assert.AreEqual(50, root_child4.LayoutX);
-            Assert.AreEqual(0, root_child4.LayoutY);
-            Assert.AreEqual(50, root_child4.LayoutWidth);
-            Assert.AreEqual(0, root_child4.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutAlignItemsTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutAlignItemsTest.cs
@@ -1,194 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutAlignItemsTest
-    {
-        [Test]
-        public void Test_align_items_stretch()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_align_items_center()
-        {
-            CSSNode root = new CSSNode();
-            root.AlignItems = CSSAlign.Center;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(45, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(45, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_align_items_flex_start()
-        {
-            CSSNode root = new CSSNode();
-            root.AlignItems = CSSAlign.FlexStart;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(90, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_align_items_flex_end()
-        {
-            CSSNode root = new CSSNode();
-            root.AlignItems = CSSAlign.FlexEnd;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(90, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutAlignSelfTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutAlignSelfTest.cs
@@ -1,197 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutAlignSelfTest
-    {
-        [Test]
-        public void Test_align_self_center()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.AlignSelf = CSSAlign.Center;
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(45, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(45, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_align_self_flex_end()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.AlignSelf = CSSAlign.FlexEnd;
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(90, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_align_self_flex_start()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.AlignSelf = CSSAlign.FlexStart;
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(90, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_align_self_flex_end_override_flex_start()
-        {
-            CSSNode root = new CSSNode();
-            root.AlignItems = CSSAlign.FlexStart;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.AlignSelf = CSSAlign.FlexEnd;
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(90, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutBorderTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutBorderTest.cs
@@ -1,234 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutBorderTest
-    {
-        [Test]
-        public void Test_border_no_size()
-        {
-            CSSNode root = new CSSNode();
-            root.SetBorder(CSSEdge.Left, 10);
-            root.SetBorder(CSSEdge.Top, 10);
-            root.SetBorder(CSSEdge.Right, 10);
-            root.SetBorder(CSSEdge.Bottom, 10);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(20, root.LayoutWidth);
-            Assert.AreEqual(20, root.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(20, root.LayoutWidth);
-            Assert.AreEqual(20, root.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_border_container_match_child()
-        {
-            CSSNode root = new CSSNode();
-            root.SetBorder(CSSEdge.Left, 10);
-            root.SetBorder(CSSEdge.Top, 10);
-            root.SetBorder(CSSEdge.Right, 10);
-            root.SetBorder(CSSEdge.Bottom, 10);
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(30, root.LayoutWidth);
-            Assert.AreEqual(30, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(30, root.LayoutWidth);
-            Assert.AreEqual(30, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_border_flex_child()
-        {
-            CSSNode root = new CSSNode();
-            root.SetBorder(CSSEdge.Left, 10);
-            root.SetBorder(CSSEdge.Top, 10);
-            root.SetBorder(CSSEdge.Right, 10);
-            root.SetBorder(CSSEdge.Bottom, 10);
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(80, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(80, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(80, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_border_stretch_child()
-        {
-            CSSNode root = new CSSNode();
-            root.SetBorder(CSSEdge.Left, 10);
-            root.SetBorder(CSSEdge.Top, 10);
-            root.SetBorder(CSSEdge.Right, 10);
-            root.SetBorder(CSSEdge.Bottom, 10);
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(80, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(80, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_border_center_child()
-        {
-            CSSNode root = new CSSNode();
-            root.JustifyContent = CSSJustify.Center;
-            root.AlignItems = CSSAlign.Center;
-            root.SetBorder(CSSEdge.Start, 10);
-            root.SetBorder(CSSEdge.End, 20);
-            root.SetBorder(CSSEdge.Bottom, 20);
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(40, root_child0.LayoutX);
-            Assert.AreEqual(35, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(50, root_child0.LayoutX);
-            Assert.AreEqual(35, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutFlexDirectionTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutFlexDirectionTest.cs
@@ -1,452 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutFlexDirectionTest
-    {
-        [Test]
-        public void Test_flex_direction_column_no_height()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(30, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(20, root_child2.LayoutY);
-            Assert.AreEqual(100, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(30, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(20, root_child2.LayoutY);
-            Assert.AreEqual(100, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_direction_row_no_width()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(30, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(10, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-
-            Assert.AreEqual(20, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(100, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(30, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(20, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(10, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(100, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_direction_column()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(20, root_child2.LayoutY);
-            Assert.AreEqual(100, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(20, root_child2.LayoutY);
-            Assert.AreEqual(100, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_direction_row()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(10, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-
-            Assert.AreEqual(20, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(100, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(90, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(80, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-
-            Assert.AreEqual(70, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(100, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_direction_column_reverse()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.ColumnReverse;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(90, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(80, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(70, root_child2.LayoutY);
-            Assert.AreEqual(100, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(90, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(80, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(70, root_child2.LayoutY);
-            Assert.AreEqual(100, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_direction_row_reverse()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.RowReverse;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(90, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(80, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-
-            Assert.AreEqual(70, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(100, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(10, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-
-            Assert.AreEqual(20, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(100, root_child2.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutFlexTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutFlexTest.cs
@@ -1,403 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutFlexTest
-    {
-        [Test]
-        public void Test_flex_basis_flex_grow_column()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.FlexBasis = 50;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.FlexGrow = 1;
-            root.Insert(1, root_child1);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(75, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(75, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(25, root_child1.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(75, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(75, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(25, root_child1.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_basis_flex_grow_row()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.FlexBasis = 50;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.FlexGrow = 1;
-            root.Insert(1, root_child1);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(75, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(75, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(25, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(25, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(75, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(25, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_basis_flex_shrink_column()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexShrink = 1;
-            root_child0.FlexBasis = 100;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.FlexBasis = 50;
-            root.Insert(1, root_child1);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(50, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(50, root_child1.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(50, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(50, root_child1.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_basis_flex_shrink_row()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexShrink = 1;
-            root_child0.FlexBasis = 100;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.FlexBasis = 50;
-            root.Insert(1, root_child1);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(50, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(50, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_shrink_to_zero()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleHeight = 75;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 50;
-            root_child0.StyleHeight = 50;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.FlexShrink = 1;
-            root_child1.StyleWidth = 50;
-            root_child1.StyleHeight = 50;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 50;
-            root_child2.StyleHeight = 50;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(50, root.LayoutWidth);
-            Assert.AreEqual(75, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(50, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(0, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(50, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(50, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(50, root.LayoutWidth);
-            Assert.AreEqual(75, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(50, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(0, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(50, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(50, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_basis_overrides_main_size()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.FlexBasis = 50;
-            root_child0.StyleHeight = 20;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.FlexGrow = 1;
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.FlexGrow = 1;
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(60, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(60, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(20, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(80, root_child2.LayoutY);
-            Assert.AreEqual(100, root_child2.LayoutWidth);
-            Assert.AreEqual(20, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(60, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(60, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(20, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(80, root_child2.LayoutY);
-            Assert.AreEqual(100, root_child2.LayoutWidth);
-            Assert.AreEqual(20, root_child2.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutFlexWrapTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutFlexWrapTest.cs
@@ -1,389 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutFlexWrapTest
-    {
-        [Test]
-        public void Test_wrap_column()
-        {
-            CSSNode root = new CSSNode();
-            root.Wrap = CSSWrap.Wrap;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 30;
-            root_child0.StyleHeight = 30;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 30;
-            root_child1.StyleHeight = 30;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 30;
-            root_child2.StyleHeight = 30;
-            root.Insert(2, root_child2);
-
-            CSSNode root_child3 = new CSSNode();
-            root_child3.StyleWidth = 30;
-            root_child3.StyleHeight = 30;
-            root.Insert(3, root_child3);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(60, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(30, root_child0.LayoutWidth);
-            Assert.AreEqual(30, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(30, root_child1.LayoutY);
-            Assert.AreEqual(30, root_child1.LayoutWidth);
-            Assert.AreEqual(30, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(60, root_child2.LayoutY);
-            Assert.AreEqual(30, root_child2.LayoutWidth);
-            Assert.AreEqual(30, root_child2.LayoutHeight);
-
-            Assert.AreEqual(30, root_child3.LayoutX);
-            Assert.AreEqual(0, root_child3.LayoutY);
-            Assert.AreEqual(30, root_child3.LayoutWidth);
-            Assert.AreEqual(30, root_child3.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(60, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(30, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(30, root_child0.LayoutWidth);
-            Assert.AreEqual(30, root_child0.LayoutHeight);
-
-            Assert.AreEqual(30, root_child1.LayoutX);
-            Assert.AreEqual(30, root_child1.LayoutY);
-            Assert.AreEqual(30, root_child1.LayoutWidth);
-            Assert.AreEqual(30, root_child1.LayoutHeight);
-
-            Assert.AreEqual(30, root_child2.LayoutX);
-            Assert.AreEqual(60, root_child2.LayoutY);
-            Assert.AreEqual(30, root_child2.LayoutWidth);
-            Assert.AreEqual(30, root_child2.LayoutHeight);
-
-            Assert.AreEqual(0, root_child3.LayoutX);
-            Assert.AreEqual(0, root_child3.LayoutY);
-            Assert.AreEqual(30, root_child3.LayoutWidth);
-            Assert.AreEqual(30, root_child3.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_wrap_row()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.Wrap = CSSWrap.Wrap;
-            root.StyleWidth = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 30;
-            root_child0.StyleHeight = 30;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 30;
-            root_child1.StyleHeight = 30;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 30;
-            root_child2.StyleHeight = 30;
-            root.Insert(2, root_child2);
-
-            CSSNode root_child3 = new CSSNode();
-            root_child3.StyleWidth = 30;
-            root_child3.StyleHeight = 30;
-            root.Insert(3, root_child3);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(60, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(30, root_child0.LayoutWidth);
-            Assert.AreEqual(30, root_child0.LayoutHeight);
-
-            Assert.AreEqual(30, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(30, root_child1.LayoutWidth);
-            Assert.AreEqual(30, root_child1.LayoutHeight);
-
-            Assert.AreEqual(60, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(30, root_child2.LayoutWidth);
-            Assert.AreEqual(30, root_child2.LayoutHeight);
-
-            Assert.AreEqual(0, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(30, root_child3.LayoutWidth);
-            Assert.AreEqual(30, root_child3.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(60, root.LayoutHeight);
-
-            Assert.AreEqual(70, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(30, root_child0.LayoutWidth);
-            Assert.AreEqual(30, root_child0.LayoutHeight);
-
-            Assert.AreEqual(40, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(30, root_child1.LayoutWidth);
-            Assert.AreEqual(30, root_child1.LayoutHeight);
-
-            Assert.AreEqual(10, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(30, root_child2.LayoutWidth);
-            Assert.AreEqual(30, root_child2.LayoutHeight);
-
-            Assert.AreEqual(70, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(30, root_child3.LayoutWidth);
-            Assert.AreEqual(30, root_child3.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_wrap_row_align_items_flex_end()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.AlignItems = CSSAlign.FlexEnd;
-            root.Wrap = CSSWrap.Wrap;
-            root.StyleWidth = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 30;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 30;
-            root_child1.StyleHeight = 20;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 30;
-            root_child2.StyleHeight = 30;
-            root.Insert(2, root_child2);
-
-            CSSNode root_child3 = new CSSNode();
-            root_child3.StyleWidth = 30;
-            root_child3.StyleHeight = 30;
-            root.Insert(3, root_child3);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(60, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(20, root_child0.LayoutY);
-            Assert.AreEqual(30, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(30, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(30, root_child1.LayoutWidth);
-            Assert.AreEqual(20, root_child1.LayoutHeight);
-
-            Assert.AreEqual(60, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(30, root_child2.LayoutWidth);
-            Assert.AreEqual(30, root_child2.LayoutHeight);
-
-            Assert.AreEqual(0, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(30, root_child3.LayoutWidth);
-            Assert.AreEqual(30, root_child3.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(60, root.LayoutHeight);
-
-            Assert.AreEqual(70, root_child0.LayoutX);
-            Assert.AreEqual(20, root_child0.LayoutY);
-            Assert.AreEqual(30, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(40, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(30, root_child1.LayoutWidth);
-            Assert.AreEqual(20, root_child1.LayoutHeight);
-
-            Assert.AreEqual(10, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(30, root_child2.LayoutWidth);
-            Assert.AreEqual(30, root_child2.LayoutHeight);
-
-            Assert.AreEqual(70, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(30, root_child3.LayoutWidth);
-            Assert.AreEqual(30, root_child3.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_wrap_row_align_items_center()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.AlignItems = CSSAlign.Center;
-            root.Wrap = CSSWrap.Wrap;
-            root.StyleWidth = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 30;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 30;
-            root_child1.StyleHeight = 20;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 30;
-            root_child2.StyleHeight = 30;
-            root.Insert(2, root_child2);
-
-            CSSNode root_child3 = new CSSNode();
-            root_child3.StyleWidth = 30;
-            root_child3.StyleHeight = 30;
-            root.Insert(3, root_child3);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(60, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(30, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(30, root_child1.LayoutX);
-            Assert.AreEqual(5, root_child1.LayoutY);
-            Assert.AreEqual(30, root_child1.LayoutWidth);
-            Assert.AreEqual(20, root_child1.LayoutHeight);
-
-            Assert.AreEqual(60, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(30, root_child2.LayoutWidth);
-            Assert.AreEqual(30, root_child2.LayoutHeight);
-
-            Assert.AreEqual(0, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(30, root_child3.LayoutWidth);
-            Assert.AreEqual(30, root_child3.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(60, root.LayoutHeight);
-
-            Assert.AreEqual(70, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(30, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(40, root_child1.LayoutX);
-            Assert.AreEqual(5, root_child1.LayoutY);
-            Assert.AreEqual(30, root_child1.LayoutWidth);
-            Assert.AreEqual(20, root_child1.LayoutHeight);
-
-            Assert.AreEqual(10, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(30, root_child2.LayoutWidth);
-            Assert.AreEqual(30, root_child2.LayoutHeight);
-
-            Assert.AreEqual(70, root_child3.LayoutX);
-            Assert.AreEqual(30, root_child3.LayoutY);
-            Assert.AreEqual(30, root_child3.LayoutWidth);
-            Assert.AreEqual(30, root_child3.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutJustifyContentTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutJustifyContentTest.cs
@@ -1,746 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutJustifyContentTest
-    {
-        [Test]
-        public void Test_justify_content_row_flex_start()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleWidth = 102;
-            root.StyleHeight = 102;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(102, root_child0.LayoutHeight);
-
-            Assert.AreEqual(10, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(102, root_child1.LayoutHeight);
-
-            Assert.AreEqual(20, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(102, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(92, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(102, root_child0.LayoutHeight);
-
-            Assert.AreEqual(82, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(102, root_child1.LayoutHeight);
-
-            Assert.AreEqual(72, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(102, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_row_flex_end()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.JustifyContent = CSSJustify.FlexEnd;
-            root.StyleWidth = 102;
-            root.StyleHeight = 102;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(72, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(102, root_child0.LayoutHeight);
-
-            Assert.AreEqual(82, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(102, root_child1.LayoutHeight);
-
-            Assert.AreEqual(92, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(102, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(20, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(102, root_child0.LayoutHeight);
-
-            Assert.AreEqual(10, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(102, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(102, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_row_center()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.JustifyContent = CSSJustify.Center;
-            root.StyleWidth = 102;
-            root.StyleHeight = 102;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(36, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(102, root_child0.LayoutHeight);
-
-            Assert.AreEqual(46, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(102, root_child1.LayoutHeight);
-
-            Assert.AreEqual(56, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(102, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(56, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(102, root_child0.LayoutHeight);
-
-            Assert.AreEqual(46, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(102, root_child1.LayoutHeight);
-
-            Assert.AreEqual(36, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(102, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_row_space_between()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.JustifyContent = CSSJustify.SpaceBetween;
-            root.StyleWidth = 102;
-            root.StyleHeight = 102;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(102, root_child0.LayoutHeight);
-
-            Assert.AreEqual(46, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(102, root_child1.LayoutHeight);
-
-            Assert.AreEqual(92, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(102, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(92, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(102, root_child0.LayoutHeight);
-
-            Assert.AreEqual(46, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(102, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(102, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_row_space_around()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.JustifyContent = CSSJustify.SpaceAround;
-            root.StyleWidth = 102;
-            root.StyleHeight = 102;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(12, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(102, root_child0.LayoutHeight);
-
-            Assert.AreEqual(46, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(102, root_child1.LayoutHeight);
-
-            Assert.AreEqual(80, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(102, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(80, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(102, root_child0.LayoutHeight);
-
-            Assert.AreEqual(46, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(10, root_child1.LayoutWidth);
-            Assert.AreEqual(102, root_child1.LayoutHeight);
-
-            Assert.AreEqual(12, root_child2.LayoutX);
-            Assert.AreEqual(0, root_child2.LayoutY);
-            Assert.AreEqual(10, root_child2.LayoutWidth);
-            Assert.AreEqual(102, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_column_flex_start()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 102;
-            root.StyleHeight = 102;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(102, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(102, root_child1.LayoutWidth);
-            Assert.AreEqual(0, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(10, root_child2.LayoutY);
-            Assert.AreEqual(102, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(102, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(10, root_child1.LayoutY);
-            Assert.AreEqual(102, root_child1.LayoutWidth);
-            Assert.AreEqual(0, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(10, root_child2.LayoutY);
-            Assert.AreEqual(102, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_column_flex_end()
-        {
-            CSSNode root = new CSSNode();
-            root.JustifyContent = CSSJustify.FlexEnd;
-            root.StyleWidth = 102;
-            root.StyleHeight = 102;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(72, root_child0.LayoutY);
-            Assert.AreEqual(102, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(82, root_child1.LayoutY);
-            Assert.AreEqual(102, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(92, root_child2.LayoutY);
-            Assert.AreEqual(102, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(72, root_child0.LayoutY);
-            Assert.AreEqual(102, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(82, root_child1.LayoutY);
-            Assert.AreEqual(102, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(92, root_child2.LayoutY);
-            Assert.AreEqual(102, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_column_center()
-        {
-            CSSNode root = new CSSNode();
-            root.JustifyContent = CSSJustify.Center;
-            root.StyleWidth = 102;
-            root.StyleHeight = 102;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(36, root_child0.LayoutY);
-            Assert.AreEqual(102, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(46, root_child1.LayoutY);
-            Assert.AreEqual(102, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(56, root_child2.LayoutY);
-            Assert.AreEqual(102, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(36, root_child0.LayoutY);
-            Assert.AreEqual(102, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(46, root_child1.LayoutY);
-            Assert.AreEqual(102, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(56, root_child2.LayoutY);
-            Assert.AreEqual(102, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_column_space_between()
-        {
-            CSSNode root = new CSSNode();
-            root.JustifyContent = CSSJustify.SpaceBetween;
-            root.StyleWidth = 102;
-            root.StyleHeight = 102;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(102, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(46, root_child1.LayoutY);
-            Assert.AreEqual(102, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(92, root_child2.LayoutY);
-            Assert.AreEqual(102, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(102, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(46, root_child1.LayoutY);
-            Assert.AreEqual(102, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(92, root_child2.LayoutY);
-            Assert.AreEqual(102, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_column_space_around()
-        {
-            CSSNode root = new CSSNode();
-            root.JustifyContent = CSSJustify.SpaceAround;
-            root.StyleWidth = 102;
-            root.StyleHeight = 102;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleHeight = 10;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleHeight = 10;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(12, root_child0.LayoutY);
-            Assert.AreEqual(102, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(46, root_child1.LayoutY);
-            Assert.AreEqual(102, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(80, root_child2.LayoutY);
-            Assert.AreEqual(102, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(102, root.LayoutWidth);
-            Assert.AreEqual(102, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(12, root_child0.LayoutY);
-            Assert.AreEqual(102, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(46, root_child1.LayoutY);
-            Assert.AreEqual(102, root_child1.LayoutWidth);
-            Assert.AreEqual(10, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(80, root_child2.LayoutY);
-            Assert.AreEqual(102, root_child2.LayoutWidth);
-            Assert.AreEqual(10, root_child2.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutMarginTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutMarginTest.cs
@@ -1,479 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutMarginTest
-    {
-        [Test]
-        public void Test_margin_start()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.SetMargin(CSSEdge.Start, 10);
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(80, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_margin_top()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.SetMargin(CSSEdge.Top, 10);
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_margin_end()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.JustifyContent = CSSJustify.FlexEnd;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.SetMargin(CSSEdge.End, 10);
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(80, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_margin_bottom()
-        {
-            CSSNode root = new CSSNode();
-            root.JustifyContent = CSSJustify.FlexEnd;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.SetMargin(CSSEdge.Bottom, 10);
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(80, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(80, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_margin_and_flex_row()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.SetMargin(CSSEdge.Start, 10);
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(90, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(90, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_margin_and_flex_column()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.SetMargin(CSSEdge.Top, 10);
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(90, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(90, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_margin_and_stretch_row()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.SetMargin(CSSEdge.Top, 10);
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(90, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(90, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_margin_and_stretch_column()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.SetMargin(CSSEdge.Start, 10);
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(90, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(90, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_margin_with_sibling_row()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.FlexGrow = 1;
-            root.Insert(1, root_child1);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(50, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(50, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_margin_with_sibling_column()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.FlexGrow = 1;
-            root.Insert(1, root_child1);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(50, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(50, root_child1.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(50, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(50, root_child1.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutMinMaxDimensionTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutMinMaxDimensionTest.cs
@@ -1,387 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutMinMaxDimensionTest
-    {
-        [Test]
-        public void Test_max_width()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleMaxWidth = 50;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(50, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_max_height()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root_child0.StyleMaxHeight = 50;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(90, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_min_height()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.StyleMinHeight = 60;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.FlexGrow = 1;
-            root.Insert(1, root_child1);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(80, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(80, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(20, root_child1.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(80, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(80, root_child1.LayoutY);
-            Assert.AreEqual(100, root_child1.LayoutWidth);
-            Assert.AreEqual(20, root_child1.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_min_width()
-        {
-            CSSNode root = new CSSNode();
-            root.FlexDirection = CSSFlexDirection.Row;
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.StyleMinWidth = 60;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.FlexGrow = 1;
-            root.Insert(1, root_child1);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(80, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(80, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(20, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(20, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(80, root_child0.LayoutWidth);
-            Assert.AreEqual(100, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(0, root_child1.LayoutY);
-            Assert.AreEqual(20, root_child1.LayoutWidth);
-            Assert.AreEqual(100, root_child1.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_min_max()
-        {
-            CSSNode root = new CSSNode();
-            root.JustifyContent = CSSJustify.Center;
-            root.StyleWidth = 100;
-            root.StyleMinHeight = 100;
-            root.StyleMaxHeight = 200;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 60;
-            root_child0.StyleHeight = 60;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(20, root_child0.LayoutY);
-            Assert.AreEqual(60, root_child0.LayoutWidth);
-            Assert.AreEqual(60, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(40, root_child0.LayoutX);
-            Assert.AreEqual(20, root_child0.LayoutY);
-            Assert.AreEqual(60, root_child0.LayoutWidth);
-            Assert.AreEqual(60, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_align_items_min_max()
-        {
-            CSSNode root = new CSSNode();
-            root.AlignItems = CSSAlign.Center;
-            root.StyleMinWidth = 100;
-            root.StyleMaxWidth = 200;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 60;
-            root_child0.StyleHeight = 60;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(20, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(60, root_child0.LayoutWidth);
-            Assert.AreEqual(60, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(20, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(60, root_child0.LayoutWidth);
-            Assert.AreEqual(60, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_justify_content_overflow_min_max()
-        {
-            CSSNode root = new CSSNode();
-            root.JustifyContent = CSSJustify.Center;
-            root.StyleMinHeight = 100;
-            root.StyleMaxHeight = 110;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 50;
-            root_child0.StyleHeight = 50;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.StyleWidth = 50;
-            root_child1.StyleHeight = 50;
-            root.Insert(1, root_child1);
-
-            CSSNode root_child2 = new CSSNode();
-            root_child2.StyleWidth = 50;
-            root_child2.StyleHeight = 50;
-            root.Insert(2, root_child2);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(50, root.LayoutWidth);
-            Assert.AreEqual(110, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(-20, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(30, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(50, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(80, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(50, root_child2.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(50, root.LayoutWidth);
-            Assert.AreEqual(110, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(-20, root_child0.LayoutY);
-            Assert.AreEqual(50, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child1.LayoutX);
-            Assert.AreEqual(30, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(50, root_child1.LayoutHeight);
-
-            Assert.AreEqual(0, root_child2.LayoutX);
-            Assert.AreEqual(80, root_child2.LayoutY);
-            Assert.AreEqual(50, root_child2.LayoutWidth);
-            Assert.AreEqual(50, root_child2.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.CSSLayout/CSSLayoutPaddingTest.cs
+++ b/csharp/tests/Facebook.CSSLayout/CSSLayoutPaddingTest.cs
@@ -1,234 +0,0 @@
-/**
- * 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.sh with the following input
- *
-<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>
- *
- */
-
-using System;
-using NUnit.Framework;
-
-namespace Facebook.CSSLayout
-{
-    [TestFixture]
-    public class CSSLayoutPaddingTest
-    {
-        [Test]
-        public void Test_padding_no_size()
-        {
-            CSSNode root = new CSSNode();
-            root.SetPadding(CSSEdge.Left, 10);
-            root.SetPadding(CSSEdge.Top, 10);
-            root.SetPadding(CSSEdge.Right, 10);
-            root.SetPadding(CSSEdge.Bottom, 10);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(20, root.LayoutWidth);
-            Assert.AreEqual(20, root.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(20, root.LayoutWidth);
-            Assert.AreEqual(20, root.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_padding_container_match_child()
-        {
-            CSSNode root = new CSSNode();
-            root.SetPadding(CSSEdge.Left, 10);
-            root.SetPadding(CSSEdge.Top, 10);
-            root.SetPadding(CSSEdge.Right, 10);
-            root.SetPadding(CSSEdge.Bottom, 10);
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(30, root.LayoutWidth);
-            Assert.AreEqual(30, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(30, root.LayoutWidth);
-            Assert.AreEqual(30, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_padding_flex_child()
-        {
-            CSSNode root = new CSSNode();
-            root.SetPadding(CSSEdge.Left, 10);
-            root.SetPadding(CSSEdge.Top, 10);
-            root.SetPadding(CSSEdge.Right, 10);
-            root.SetPadding(CSSEdge.Bottom, 10);
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexGrow = 1;
-            root_child0.StyleWidth = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(80, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(80, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(80, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_padding_stretch_child()
-        {
-            CSSNode root = new CSSNode();
-            root.SetPadding(CSSEdge.Left, 10);
-            root.SetPadding(CSSEdge.Top, 10);
-            root.SetPadding(CSSEdge.Right, 10);
-            root.SetPadding(CSSEdge.Bottom, 10);
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(80, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(10, root_child0.LayoutX);
-            Assert.AreEqual(10, root_child0.LayoutY);
-            Assert.AreEqual(80, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_padding_center_child()
-        {
-            CSSNode root = new CSSNode();
-            root.JustifyContent = CSSJustify.Center;
-            root.AlignItems = CSSAlign.Center;
-            root.SetPadding(CSSEdge.Start, 10);
-            root.SetPadding(CSSEdge.End, 20);
-            root.SetPadding(CSSEdge.Bottom, 20);
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.StyleWidth = 10;
-            root_child0.StyleHeight = 10;
-            root.Insert(0, root_child0);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(40, root_child0.LayoutX);
-            Assert.AreEqual(35, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(100, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(50, root_child0.LayoutX);
-            Assert.AreEqual(35, root_child0.LayoutY);
-            Assert.AreEqual(10, root_child0.LayoutWidth);
-            Assert.AreEqual(10, root_child0.LayoutHeight);
-        }
-
-    }
-}
--- a/csharp/tests/Facebook.Yoga/YGAbsolutePositionTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/csharp/tests/Facebook.Yoga/YGAlignContentTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/csharp/tests/Facebook.Yoga/YGAlignItemsTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/csharp/tests/Facebook.Yoga/YGAlignSelfTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/csharp/tests/Facebook.Yoga/YGBorderTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/csharp/tests/Facebook.Yoga/YGFlexDirectionTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/csharp/tests/Facebook.Yoga/YGFlexTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/csharp/tests/Facebook.Yoga/YGFlexWrapTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/csharp/tests/Facebook.Yoga/YGJustifyContentTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/csharp/tests/Facebook.Yoga/YGMarginTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/csharp/tests/Facebook.Yoga/YGMinMaxDimensionTest.cs
+++ b/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);
+        }
+
+    }
+}
--- a/Show More
+++ b/Show More