Rename java API

Summary: Rename java api to new use yoga naming

Reviewed By: IanChilds

Differential Revision: D4265345

fbshipit-source-id: 69ecfd8fac214f86b8b70647b9b909acd83d78b5

.gitignore

@@ -4,7 +4,6 @@
 /buck-out/
 /.buckconfig.local
 /.buckd
-/lib/gtest/googletest-*/
 /gentest/test.html
 
 # Visual studio code

.gitmodules

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

.hgignore

@@ -4,7 +4,6 @@
 /buck-out/
 /.buckconfig.local
 /.buckd
-/lib/gtest/googletest-*/
 /gentest/test.html
 
 # Visual studio code

.travis.yml

@@ -14,14 +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 //java:java
-  - buck test //CSSLayoutKit:CSSLayoutKit --config cxx.default_platform=iphonesimulator-x86_64
-  - sh csharp/tests/Facebook.CSSLayout/test_macos.sh
+  - buck test //YogaKit:YogaKit --config cxx.default_platform=iphonesimulator-x86_64 --config cxx.cflags=-DTRAVIS_CI
+  - sh csharp/tests/Facebook.Yoga/test_macos.sh
   - buck run //benchmark:benchmark
   - git checkout HEAD^
   - buck run //benchmark:benchmark

BUCK

@@ -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,7 +20,7 @@ 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(
@@ -29,9 +29,10 @@ cxx_library(
   tests=[':tests'],
   exported_headers = subdir_glob([('', 'CSSLayout/*.h')]),
   header_namespace = '',
-  force_static = True,
   compiler_flags = COMPILER_FLAGS,
-  deps = [],
+  deps = [] if THIS_IS_FBOBJC else [
+    csslayout_dep('lib/fb:ndklog'),
+  ],
   visibility = ['PUBLIC'],
 )
 

CSSLayout/CSSLayout.h

@@ -1,241 +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 enum CSSLogLevel {
-  CSSLogLevelError,
-  CSSLogLevelWarn,
-  CSSLogLevelInfo,
-  CSSLogLevelDebug,
-  CSSLogLevelVerbose,
-} CSSLogLevel;
-
-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)(CSSLogLevel level, const char *format, va_list args);
-
-// 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 CSSNodePrint(const CSSNodeRef node, const CSSPrintOptions options);
-
-WIN_EXPORT bool CSSValueIsUndefined(const float value);
-
-WIN_EXPORT bool CSSNodeCanUseCachedMeasurement(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, 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);
-WIN_EXPORT void CSSLog(CSSLogLevel level, const char *message, ...);
-
-CSS_EXTERN_C_END

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;
-}

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

CSSLayout/YGEnums.h

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

CSSLayout/YGMacros.h

@@ -10,11 +10,11 @@
 #pragma once
 
 #ifdef __cplusplus
-#define CSS_EXTERN_C_BEGIN extern "C" {
-#define CSS_EXTERN_C_END }
+#define YG_EXTERN_C_BEGIN extern "C" {
+#define YG_EXTERN_C_END }
 #else
-#define CSS_EXTERN_C_BEGIN
-#define CSS_EXTERN_C_END
+#define YG_EXTERN_C_BEGIN
+#define YG_EXTERN_C_END
 #endif
 
 #ifdef _WINDLL
@@ -28,15 +28,15 @@
 #endif
 
 #if FB_ASSERTIONS_ENABLED
-#define CSS_ABORT() abort()
+#define YG_ABORT() abort()
 #else
-#define CSS_ABORT()
+#define YG_ABORT()
 #endif
 
-#ifndef CSS_ASSERT
-#define CSS_ASSERT(X, message)               \
+#ifndef YG_ASSERT
+#define YG_ASSERT(X, message)              \
   if (!(X)) {                              \
-    CSSLog(CSSLogLevelError, "%s", message); \
-    CSS_ABORT();                             \
+    YGLog(YGLogLevelError, "%s", message); \
+    YG_ABORT();                            \
   }
 #endif

CSSLayout/YGNodeList.c

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

CSSLayout/YGNodeList.h

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

CSSLayout/Yoga.h

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

CSSLayoutKit/Tests/CSSLayoutTests.m

@@ -1,110 +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.
- */
-
-#import <XCTest/XCTest.h>
-
-#import "UIView+CSSLayout.h"
-
-@interface CSSLayoutTests : XCTestCase
-@end
-
-@implementation CSSLayoutTests
-
-- (void)testNodesAreDeallocedWithSingleView
-{
-  XCTAssertEqual(0, CSSNodeGetInstanceCount());
-
-  UIView *view = [[UIView alloc] initWithFrame:CGRectZero];
-  [view css_setFlexBasis:1];
-  XCTAssertEqual(1, CSSNodeGetInstanceCount());
-  view = nil;
-
-  XCTAssertEqual(0, CSSNodeGetInstanceCount());
-}
-
-- (void)testNodesAreDeallocedCascade
-{
-  XCTAssertEqual(0, CSSNodeGetInstanceCount());
-
-  UIView *view = [[UIView alloc] initWithFrame:CGRectZero];
-  [view css_setFlexBasis:1];
-
-  for (int i=0; i<10; i++) {
-    UIView *subview = [[UIView alloc] initWithFrame:CGRectZero];
-    [subview css_setFlexBasis:1];
-    [view addSubview:subview];
-  }
-  XCTAssertEqual(11, CSSNodeGetInstanceCount());
-  view = nil;
-
-  XCTAssertEqual(0, CSSNodeGetInstanceCount());
-}
-
-- (void)testUsesFlexbox
-{
-  UIView *view = [[UIView alloc] initWithFrame:CGRectZero];
-  XCTAssertFalse([view css_usesFlexbox]);
-
-  [view css_setUsesFlexbox:YES];
-  XCTAssertTrue([view css_usesFlexbox]);
-
-  [view css_setUsesFlexbox:NO];
-  XCTAssertFalse([view css_usesFlexbox]);
-}
-
-- (void)testSizeThatFitsAsserts
-{
-  UIView *view = [[UIView alloc] initWithFrame:CGRectZero];
-  XCTAssertThrows([view css_sizeThatFits:CGSizeZero]);
-
-  dispatch_sync(dispatch_queue_create("com.facebook.CSSLayout.testing", DISPATCH_QUEUE_SERIAL), ^(void){
-    XCTAssertThrows([view css_sizeThatFits:CGSizeZero]);
-  });
-}
-
-- (void)testSizeThatFitsSmoke
-{
-  UIView *view = [[UIView alloc] initWithFrame:CGRectZero];
-  [view css_setUsesFlexbox:YES];
-
-  const CGSize constrainedSize = CGSizeMake(50, 50);
-  const CGSize actualSize = [view css_sizeThatFits:constrainedSize];
-  XCTAssertTrue(CGSizeEqualToSize(constrainedSize, actualSize), @"Actual Size: %@", NSStringFromCGSize(actualSize));
-}
-
-- (void)testFrameAndOriginPlacement
-{
-  const CGSize containerSize = CGSizeMake(320, 50);
-
-  UIView *container = [[UIView alloc] initWithFrame:CGRectMake(0, 0, containerSize.width, containerSize.height)];
-  [container css_setUsesFlexbox:YES];
-  [container css_setFlexDirection:CSSFlexDirectionRow];
-
-  for (int i = 0; i < 3; i++) {
-    UIView *subview = [[UIView alloc] initWithFrame:CGRectZero];
-    [subview css_setUsesFlexbox:YES];
-    [subview css_setFlexGrow:1];
-
-    [container addSubview:subview];
-  }
-  [container css_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);
-}
-
-@end

CSSLayoutKit/UIView+CSSLayout.h

@@ -1,59 +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.
- */
-
-#import <UIKit/UIKit.h>
-#import <CSSLayout/CSSLayout.h>
-
-@interface UIView (CSSLayout)
-
-/**
- The property that decides during layout/sizing whether or not css_* properties should be applied. Defaults to NO.
- */
-@property (nonatomic, readwrite, assign, setter=css_setUsesFlexbox:) BOOL css_usesFlexbox;
-
-- (void)css_setDirection:(CSSDirection)direction;
-- (void)css_setFlexDirection:(CSSFlexDirection)flexDirection;
-- (void)css_setJustifyContent:(CSSJustify)justifyContent;
-- (void)css_setAlignContent:(CSSAlign)alignContent;
-- (void)css_setAlignItems:(CSSAlign)alignItems;
-- (void)css_setAlignSelf:(CSSAlign)alignSelf;
-- (void)css_setPositionType:(CSSPositionType)positionType;
-- (void)css_setFlexWrap:(CSSWrapType)flexWrap;
-
-- (void)css_setFlexGrow:(CGFloat)flexGrow;
-- (void)css_setFlexShrink:(CGFloat)flexShrink;
-- (void)css_setFlexBasis:(CGFloat)flexBasis;
-
-- (void)css_setPosition:(CGFloat)position forEdge:(CSSEdge)edge;
-- (void)css_setMargin:(CGFloat)margin forEdge:(CSSEdge)edge;
-- (void)css_setPadding:(CGFloat)padding forEdge:(CSSEdge)edge;
-
-- (void)css_setWidth:(CGFloat)width;
-- (void)css_setHeight:(CGFloat)height;
-- (void)css_setMinWidth:(CGFloat)minWidth;
-- (void)css_setMinHeight:(CGFloat)minHeight;
-- (void)css_setMaxWidth:(CGFloat)maxWidth;
-- (void)css_setMaxHeight:(CGFloat)maxHeight;
-
-/**
- Get the resolved direction of this node. This won't be CSSDirectionInherit
- */
-- (CSSDirection)css_resolvedDirection;
-
-/**
- Perform a layout calculation and update the frames of the views in the hierarchy with th results
- */
-- (void)css_applyLayout;
-
-/**
- Compute the size of a layout with a constrained size.
- */
-- (CGSize)css_sizeThatFits:(CGSize)constrainedSize;
-
-@end

CSSLayoutKit/UIView+CSSLayout.m

@@ -1,315 +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.
- */
-
-#import "UIView+CSSLayout.h"
-
-#import <objc/runtime.h>
-
-@interface CSSNodeBridge : NSObject
-@property (nonatomic, assign, readonly) CSSNodeRef cnode;
-@end
-
-@implementation CSSNodeBridge
-- (instancetype)init
-{
-  if ([super init]) {
-    _cnode = CSSNodeNew();
-  }
-
-  return self;
-}
-
-- (void)dealloc
-{
-  CSSNodeFree(_cnode);
-}
-@end
-
-@implementation UIView (CSSLayout)
-
-- (BOOL)css_usesFlexbox
-{
-  NSNumber *usesFlexbox = objc_getAssociatedObject(self, @selector(css_usesFlexbox));
-  return [usesFlexbox boolValue];
-}
-
-#pragma mark - Setters
-
-- (void)css_setUsesFlexbox:(BOOL)enabled
-{
-  objc_setAssociatedObject(
-    self,
-    @selector(css_usesFlexbox),
-    @(enabled),
-    OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-}
-
-- (void)css_setDirection:(CSSDirection)direction
-{
-  CSSNodeStyleSetDirection([self cssNode], direction);
-}
-
-- (void)css_setFlexDirection:(CSSFlexDirection)flexDirection
-{
-  CSSNodeStyleSetFlexDirection([self cssNode], flexDirection);
-}
-
-- (void)css_setJustifyContent:(CSSJustify)justifyContent
-{
-  CSSNodeStyleSetJustifyContent([self cssNode], justifyContent);
-}
-
-- (void)css_setAlignContent:(CSSAlign)alignContent
-{
-  CSSNodeStyleSetAlignContent([self cssNode], alignContent);
-}
-
-- (void)css_setAlignItems:(CSSAlign)alignItems
-{
-  CSSNodeStyleSetAlignItems([self cssNode], alignItems);
-}
-
-- (void)css_setAlignSelf:(CSSAlign)alignSelf
-{
-  CSSNodeStyleSetAlignSelf([self cssNode], alignSelf);
-}
-
-- (void)css_setPositionType:(CSSPositionType)positionType
-{
-  CSSNodeStyleSetPositionType([self cssNode], positionType);
-}
-
-- (void)css_setFlexWrap:(CSSWrapType)flexWrap
-{
-  CSSNodeStyleSetFlexWrap([self cssNode], flexWrap);
-}
-
-- (void)css_setFlexGrow:(CGFloat)flexGrow
-{
-  CSSNodeStyleSetFlexGrow([self cssNode], flexGrow);
-}
-
-- (void)css_setFlexShrink:(CGFloat)flexShrink
-{
-  CSSNodeStyleSetFlexShrink([self cssNode], flexShrink);
-}
-
-- (void)css_setFlexBasis:(CGFloat)flexBasis
-{
-  CSSNodeStyleSetFlexBasis([self cssNode], flexBasis);
-}
-
-- (void)css_setPosition:(CGFloat)position forEdge:(CSSEdge)edge
-{
-  CSSNodeStyleSetPosition([self cssNode], edge, position);
-}
-
-- (void)css_setMargin:(CGFloat)margin forEdge:(CSSEdge)edge
-{
-  CSSNodeStyleSetMargin([self cssNode], edge, margin);
-}
-
-- (void)css_setPadding:(CGFloat)padding forEdge:(CSSEdge)edge
-{
-  CSSNodeStyleSetPadding([self cssNode], edge, padding);
-}
-
-- (void)css_setWidth:(CGFloat)width
-{
-  CSSNodeStyleSetWidth([self cssNode], width);
-}
-
-- (void)css_setHeight:(CGFloat)height
-{
-  CSSNodeStyleSetHeight([self cssNode], height);
-}
-
-- (void)css_setMinWidth:(CGFloat)minWidth
-{
-  CSSNodeStyleSetMinWidth([self cssNode], minWidth);
-}
-
-- (void)css_setMinHeight:(CGFloat)minHeight
-{
-  CSSNodeStyleSetMinHeight([self cssNode], minHeight);
-}
-
-- (void)css_setMaxWidth:(CGFloat)maxWidth
-{
-  CSSNodeStyleSetMaxWidth([self cssNode], maxWidth);
-}
-
-- (void)css_setMaxHeight:(CGFloat)maxHeight
-{
-  CSSNodeStyleSetMaxHeight([self cssNode], maxHeight);
-}
-
-#pragma mark - Layout and Sizing
-
-- (CSSDirection)css_resolvedDirection
-{
-  return CSSNodeLayoutGetDirection([self cssNode]);
-}
-
-- (CGSize)css_sizeThatFits:(CGSize)constrainedSize
-{
-  NSAssert([NSThread isMainThread], @"CSS Layout calculation must be done on main.");
-  NSAssert([self css_usesFlexbox], @"CSS Layout is not enabled for this view.");
-
-  CLKAttachNodesFromViewHierachy(self);
-
-  const CSSNodeRef node = [self cssNode];
-  CSSNodeCalculateLayout(
-    node,
-    constrainedSize.width,
-    constrainedSize.height,
-    CSSNodeStyleGetDirection(node));
-
-  return (CGSize) {
-    .width = CSSNodeLayoutGetWidth(node),
-    .height = CSSNodeLayoutGetHeight(node),
-  };
-}
-
-- (void)css_applyLayout
-{
-  [self css_sizeThatFits:self.bounds.size];
-  CLKApplyLayoutToViewHierarchy(self);
-}
-
-#pragma mark - Private
-
-- (CSSNodeRef)cssNode
-{
-  CSSNodeBridge *node = objc_getAssociatedObject(self, @selector(cssNode));
-  if (!node) {
-    node = [CSSNodeBridge new];
-    CSSNodeSetContext(node.cnode, (__bridge void *) self);
-    objc_setAssociatedObject(self, @selector(cssNode), node, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-  }
-
-  return node.cnode;
-}
-
-static CSSSize CLKMeasureView(
-  CSSNodeRef node,
-  float width,
-  CSSMeasureMode widthMode,
-  float height,
-  CSSMeasureMode heightMode)
-{
-  const CGFloat constrainedWidth = (widthMode == CSSMeasureModeUndefined) ? CGFLOAT_MAX : width;
-  const CGFloat constrainedHeight = (heightMode == CSSMeasureModeUndefined) ? CGFLOAT_MAX: height;
-
-  UIView *view = (__bridge UIView*) CSSNodeGetContext(node);
-  const CGSize sizeThatFits = [view sizeThatFits:(CGSize) {
-    .width = constrainedWidth,
-    .height = constrainedHeight,
-  }];
-
-  return (CSSSize) {
-    .width = CLKSanitizeMeasurement(constrainedWidth, sizeThatFits.width, widthMode),
-    .height = CLKSanitizeMeasurement(constrainedHeight, sizeThatFits.height, heightMode),
-  };
-}
-
-static CGFloat CLKSanitizeMeasurement(
-  CGFloat constrainedSize,
-  CGFloat measuredSize,
-  CSSMeasureMode measureMode)
-{
-  CGFloat result;
-  if (measureMode == CSSMeasureModeExactly) {
-    result = constrainedSize;
-  } else if (measureMode == CSSMeasureModeAtMost) {
-    result = MIN(constrainedSize, measuredSize);
-  } else {
-    result = measuredSize;
-  }
-
-  return result;
-}
-
-static void CLKAttachNodesFromViewHierachy(UIView *view) {
-  CSSNodeRef node = [view cssNode];
-  const BOOL usesFlexbox = [view css_usesFlexbox];
-  const BOOL isLeaf = !usesFlexbox || view.subviews.count == 0;
-
-  // Only leaf nodes should have a measure function
-  if (isLeaf) {
-    CSSNodeSetMeasureFunc(node, CLKMeasureView);
-
-    // Clear any children
-    while (CSSNodeChildCount(node) > 0) {
-      CSSNodeRemoveChild(node, CSSNodeGetChild(node, 0));
-    }
-  } else {
-    CSSNodeSetMeasureFunc(node, NULL);
-
-    // Add any children which were added since the last call to css_applyLayout
-    for (NSUInteger i = 0; i < view.subviews.count; i++) {
-      CSSNodeRef childNode = [view.subviews[i] cssNode];
-      if (CSSNodeChildCount(node) < i + 1 || CSSNodeGetChild(node, i) != childNode) {
-        CSSNodeInsertChild(node, childNode, i);
-      }
-      CLKAttachNodesFromViewHierachy(view.subviews[i]);
-    }
-
-    // Remove any children which were removed since the last call to css_applyLayout
-    while (view.subviews.count < CSSNodeChildCount(node)) {
-      CSSNodeRemoveChild(node, CSSNodeGetChild(node, CSSNodeChildCount(node) - 1));
-    }
-  }
-}
-
-static CGFloat CLKRoundPixelValue(CGFloat value)
-{
-  static CGFloat scale;
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^(){
-    scale = [UIScreen mainScreen].scale;
-  });
-
-  return round(value * scale) / scale;
-}
-
-static void CLKApplyLayoutToViewHierarchy(UIView *view) {
-  NSCAssert([NSThread isMainThread], @"Framesetting should only be done on the main thread.");
-  CSSNodeRef node = [view cssNode];
-
-  const CGPoint topLeft = {
-    CSSNodeLayoutGetLeft(node),
-    CSSNodeLayoutGetTop(node),
-  };
-
-  const CGPoint bottomRight = {
-    topLeft.x + CSSNodeLayoutGetWidth(node),
-    topLeft.y + CSSNodeLayoutGetHeight(node),
-  };
-
-  view.frame = (CGRect) {
-    .origin = {
-      .x = CLKRoundPixelValue(topLeft.x),
-      .y = CLKRoundPixelValue(topLeft.y),
-    },
-    .size = {
-      .width = CLKRoundPixelValue(bottomRight.x) - CLKRoundPixelValue(topLeft.x),
-      .height = CLKRoundPixelValue(bottomRight.y) - CLKRoundPixelValue(topLeft.y),
-    },
-  };
-
-  const BOOL isLeaf = ![view css_usesFlexbox] || view.subviews.count == 0;
-  if (!isLeaf) {
-    for (NSUInteger i = 0; i < view.subviews.count; i++) {
-      CLKApplyLayoutToViewHierarchy(view.subviews[i]);
-    }
-  }
-}
-
-@end

README.md

@@ -1,5 +1,8 @@
 # CSSLayout [![Build Status](https://travis-ci.org/facebook/css-layout.svg?branch=master)](https://travis-ci.org/facebook/css-layout)
 
+## NOTICE
+A lot is changing this week in the API regarding naming. We suggest you hold off updating to the latest version of the code until this notice is gone. Expect it to take about a week.
+
 ## 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.
 
@@ -58,7 +61,7 @@ for (uint32_t i = 0; i < 10; i++) {
   CSSNodeInsertChild(root, child, 0);
 }
 
-CSSNodeCalculateLayout(root, CSSUndefined, CSSUndefined, CSSDirectionLTR);
+CSSNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 
 // Get for resulting layout
 CSSNodeLayoutGetLeft(root);
@@ -91,23 +94,23 @@ root.getLayoutHeight();
 ```
 
 ### UIKit
-The full API can be found in `CSSLayoutKit/UIView+CSSLayout.h`.
+The full API can be found in `YogaKit/UIView+Yoga.h`.
 
 ```objective-c
 UIView *root = [UIView new];
-[root css_setUsesFlexbox:YES];
-[root css_setWidth:100];
-[root css_setHeight:100];
+[root yg_setUsesYoga:YES];
+[root yg_setWidth:100];
+[root yg_setHeight:100];
 
 for (NSUInteger i = 0; i < 10; i++) {
   UIView *child = [UIView new];
-  [child css_setUsesFlexbox:YES];
-  [child css_setHeight:10];
+  [child yg_setUsesYoga:YES];
+  [child yg_setHeight:10];
   [root addSubview:child];
 }
 
 // Resulting layout will be set on the UIView hierarchy frames.
-[root css_applyLayout];
+[root yg_applyLayout];
 ```
 
 ### .NET

YOGA_DEFS

@@ -6,12 +6,13 @@ 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_TARGET = '//lib/jni:jni'
 FBJNI_TARGET = '//lib/fb:fbjni'
 
+THIS_IS_FBOBJC = False
+
 CXX_LIBRARY_WHITELIST = [
+  '//:CSSLayout',
   '//lib/fb:fbjni',
   '//java:jni',
 ]

YogaKit/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')
 
 UIKIT_CSSLAYOUT_COMPILER_FLAGS = [
   '-fobjc-arc',
@@ -28,9 +28,9 @@ UIKIT_CSSLAYOUT_COMPILER_FLAGS = [
 ]
 
 apple_library(
-  name = 'CSSLayoutKit',
+  name = 'YogaKit',
   compiler_flags = UIKIT_CSSLAYOUT_COMPILER_FLAGS,
-  tests = [':CSSLayoutKitTests'],
+  tests = [':YogaKitTests'],
   srcs = glob(['*.m']),
   exported_headers = glob(['*.h']),
   frameworks = [
@@ -44,7 +44,7 @@ apple_library(
 )
 
 apple_test(
-  name = 'CSSLayoutKitTests',
+  name = 'YogaKitTests',
   compiler_flags = UIKIT_CSSLAYOUT_COMPILER_FLAGS,
   info_plist = 'Tests/Info.plist',
   srcs = glob(['Tests/**/*.m']),
@@ -53,7 +53,7 @@ apple_test(
     '$PLATFORM_DIR/Developer/Library/Frameworks/XCTest.framework',
   ],
   deps = [
-    ':CSSLayoutKit',
+    ':YogaKit',
   ],
   visibility = ['PUBLIC'],
 )

YogaKit/Tests/YogaKitTests.m

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

YogaKit/UIView+Yoga.h

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

YogaKit/UIView+Yoga.m

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

benchmark/BUCK

@@ -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',

benchmark/CSSBenchmark.c

@@ -1,118 +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();
-      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);
-  });
-
-});

benchmark/YGBenchmark.c

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

benchmark/YGBenchmark.h

@@ -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 }                                            \

csharp/BUCK

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

csharp/Facebook.CSSLayout/CSSNode.cs

@@ -1,554 +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()
-        {
-            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 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.Func orig = CSSLogger.Logger;
-            CSSLogger.Logger = (level, message) => {sb.Append(message);};
-            Native.CSSNodePrint(_cssNode, options);
-            CSSLogger.Logger = orig;
-            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();
-        }
-    }
-}

csharp/Facebook.CSSLayout/Native.cs

@@ -1,268 +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 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 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
-    }
-}

csharp/Facebook.Yoga.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

csharp/Facebook.Yoga/Facebook.Yoga.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>

csharp/Facebook.Yoga/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);
 }

csharp/Facebook.Yoga/MeasureOutput.cs

@@ -7,7 +7,7 @@
  * of patent rights can be found in the PATENTS file in the same directory.
  */
 
-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
     public class MeasureOutput
     {
@@ -18,7 +18,7 @@ namespace Facebook.CSSLayout
 
         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)

csharp/Facebook.Yoga/Native.cs

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

csharp/Facebook.Yoga/Properties/AssemblyInfo.cs

@@ -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

csharp/Facebook.Yoga/Spacing.cs

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

csharp/Facebook.Yoga/YogaAlign.cs

@@ -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,
     }
 }

csharp/Facebook.Yoga/YogaConstants.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;
 

csharp/Facebook.Yoga/YogaDimension.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,
     }
 }

csharp/Facebook.Yoga/YogaDirection.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,
     }
 }

csharp/Facebook.Yoga/YogaEdge.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,
     }
 }

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,
+    }
+}

csharp/Facebook.Yoga/YogaFlexDirection.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,

csharp/Facebook.Yoga/YogaJustify.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,

csharp/Facebook.Yoga/YogaLogLevel.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 CSSLogLevel
+    public enum YogaLogLevel
     {
         Error,
         Warn,

csharp/Facebook.Yoga/YogaLogger.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(CSSLogLevel level, string message);
+        public delegate void Func(YogaLogLevel level, string message);
 
         private static bool _initialized;
         private static Func _managedLogger = null;
@@ -32,12 +32,12 @@ namespace Facebook.CSSLayout
                         Logger(level, message);
                     }
 
-                    if (level == CSSLogLevel.Error)
+                    if (level == YogaLogLevel.Error)
                     {
                         throw new InvalidOperationException(message);
                     }
                 };
-                Native.CSSInteropSetLogger(_managedLogger);
+                Native.YGInteropSetLogger(_managedLogger);
                 _initialized = true;
             }
         }

csharp/Facebook.Yoga/YogaMeasureFunc.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);
 }

csharp/Facebook.Yoga/YogaMeasureMode.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,
     }
 }

csharp/Facebook.Yoga/YogaNode.Create.cs

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

csharp/Facebook.Yoga/YogaNode.cs

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

csharp/Facebook.Yoga/YogaOverflow.cs

@@ -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,
     }
 }

csharp/Facebook.Yoga/YogaPositionType.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,
     }
 }

csharp/Facebook.Yoga/YogaPrintOptions.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,

csharp/Facebook.Yoga/YogaSize.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;

csharp/Facebook.Yoga/YogaWrap.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,

csharp/Yoga/YGInterop.cpp

@@ -7,11 +7,11 @@
  * 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(CSSLogLevel level, const char *format, va_list args) {
+static int unmanagedLogger(YGLogLevel level, const char *format, va_list args) {
   int result = 0;
   if (gManagedFunc) {
     char buffer[256];
@@ -21,7 +21,7 @@ static int unmanagedLogger(CSSLogLevel level, const char *format, va_list args)
   return result;
 }
 
-void CSSInteropSetLogger(CSSInteropLoggerFunc managedFunc) {
+void YGInteropSetLogger(YGInteropLoggerFunc managedFunc) {
   gManagedFunc = managedFunc;
-  CSSLayoutSetLogger(&unmanagedLogger);
+  YGSetLogger(&unmanagedLogger);
 }

csharp/Yoga/YGInterop.h

@@ -9,12 +9,12 @@
 
 #pragma once
 
-#include <CSSLayout/CSSLayout.h>
+#include <CSSLayout/Yoga.h>
 
-CSS_EXTERN_C_BEGIN
+YG_EXTERN_C_BEGIN
 
-typedef void (*CSSInteropLoggerFunc)(CSSLogLevel level, 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

csharp/Yoga/Yoga.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="..\..\CSSLayout\Yoga.h" />
+    <ClInclude Include="..\..\CSSLayout\YGMacros.h" />
+    <ClInclude Include="..\..\CSSLayout\YGNodeList.h" />
+    <ClInclude Include="YGInterop.h" />
     <ClInclude Include="stdafx.h" />
     <ClInclude Include="targetver.h" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\CSSLayout\CSSLayout.c" />
-    <ClCompile Include="..\..\CSSLayout\CSSNodeList.c" />
-    <ClCompile Include="CSSInterop.cpp" />
+    <ClCompile Include="..\..\CSSLayout\Yoga.c" />
+    <ClCompile Include="..\..\CSSLayout\YGNodeList.c" />
+    <ClCompile Include="YGInterop.cpp" />
     <ClCompile Include="dllmain.cpp">
       <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</CompileAsManaged>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

csharp/Yoga/Yoga.vcxproj.filters

@@ -21,16 +21,16 @@
     <ClInclude Include="targetver.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\CSSLayout\CSSLayout.h">
+    <ClInclude Include="..\..\CSSLayout\Yoga.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\CSSLayout\CSSMacros.h">
+    <ClInclude Include="..\..\CSSLayout\YGMacros.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\CSSLayout\CSSNodeList.h">
+    <ClInclude Include="..\..\CSSLayout\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="..\..\CSSLayout\Yoga.c">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\CSSLayout\CSSNodeList.c">
+    <ClCompile Include="..\..\CSSLayout\YGNodeList.c">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="CSSInterop.cpp">
+    <ClCompile Include="YGInterop.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>

csharp/Yoga/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"

csharp/tests/Facebook.CSSLayout/CSSLayoutAbsolutePositionTest.cs

@@ -1,344 +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: 0px; top: 0px;">
-    <div style="width: 100px; height: 100px;"></div>
-  </div>
-</div>
-
-<div id="absolute_layout_within_border" style="height:100px; width:100px; border-width: 10px; margin: 10px; padding: 10px;">
-  <div style="position: absolute; width: 50px; height: 50px; left: 0px; top: 0px;"></div>
-  <div style="position: absolute; width: 50px; height: 50px; right: 0px; bottom: 0px;"></div>
-</div>
- *
- */
-
-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_child0.SetPosition(CSSEdge.Start, 0);
-            root_child0.SetPosition(CSSEdge.Top, 0);
-            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);
-        }
-
-        [Test]
-        public void Test_absolute_layout_within_border()
-        {
-            CSSNode root = new CSSNode();
-            root.SetMargin(CSSEdge.Left, 10);
-            root.SetMargin(CSSEdge.Top, 10);
-            root.SetMargin(CSSEdge.Right, 10);
-            root.SetMargin(CSSEdge.Bottom, 10);
-            root.SetPadding(CSSEdge.Left, 10);
-            root.SetPadding(CSSEdge.Top, 10);
-            root.SetPadding(CSSEdge.Right, 10);
-            root.SetPadding(CSSEdge.Bottom, 10);
-            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.PositionType = CSSPositionType.Absolute;
-            root_child0.SetPosition(CSSEdge.Left, 0);
-            root_child0.SetPosition(CSSEdge.Top, 0);
-            root_child0.StyleWidth = 50;
-            root_child0.StyleHeight = 50;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child1 = new CSSNode();
-            root_child1.PositionType = CSSPositionType.Absolute;
-            root_child1.SetPosition(CSSEdge.Right, 0);
-            root_child1.SetPosition(CSSEdge.Bottom, 0);
-            root_child1.StyleWidth = 50;
-            root_child1.StyleHeight = 50;
-            root.Insert(1, root_child1);
-            root.StyleDirection = CSSDirection.LeftToRight;
-            root.CalculateLayout();
-
-            Assert.AreEqual(10, root.LayoutX);
-            Assert.AreEqual(10, 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(50, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            Assert.AreEqual(40, root_child1.LayoutX);
-            Assert.AreEqual(40, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(50, root_child1.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(10, root.LayoutX);
-            Assert.AreEqual(10, 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(50, root_child0.LayoutWidth);
-            Assert.AreEqual(50, root_child0.LayoutHeight);
-
-            Assert.AreEqual(40, root_child1.LayoutX);
-            Assert.AreEqual(40, root_child1.LayoutY);
-            Assert.AreEqual(50, root_child1.LayoutWidth);
-            Assert.AreEqual(50, root_child1.LayoutHeight);
-        }
-
-    }
-}

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);
-        }
-
-    }
-}

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);
-        }
-
-    }
-}

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);
-        }
-
-    }
-}

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);
-        }
-
-    }
-}

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);
-        }
-
-    }
-}

csharp/tests/Facebook.CSSLayout/CSSLayoutFlexTest.cs

@@ -1,460 +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>
-
-<div id="flex_grow_shrink_at_most" style="height: 100px; width: 100px;">
-  <div>
-    <div style="flex-grow:1; flex-shrink:1;"></div>
-  </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);
-        }
-
-        [Test]
-        public void Test_flex_grow_shrink_at_most()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 100;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root.Insert(0, root_child0);
-
-            CSSNode root_child0_child0 = new CSSNode();
-            root_child0_child0.FlexGrow = 1;
-            root_child0_child0.FlexShrink = 1;
-            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(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(0, 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(0, root_child0_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(0, 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(0, root_child0_child0.LayoutHeight);
-        }
-
-    }
-}

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);
-        }
-
-    }
-}

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);
-        }
-
-    }
-}

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);
-        }
-
-    }
-}

csharp/tests/Facebook.CSSLayout/CSSLayoutMinMaxDimensionTest.cs

@@ -1,505 +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>
-
-<div id="flex_grow_within_max_width" style="width: 200px; height: 100px;">
-  <div style="flex-direction: row; max-width: 100px;">
-    <div style="height: 20px; flex-grow: 1;"></div>
-  </div>
-</div>
-
-<div id="flex_grow_within_constrained_max_width" style="width: 200px; height: 100px;">
-  <div style="flex-direction: row; max-width: 300px;">
-    <div style="height: 20px; flex-grow: 1;"></div>
-  </div>
-</div>
- *
- */
-
-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);
-        }
-
-        [Test]
-        public void Test_flex_grow_within_max_width()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 200;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexDirection = CSSFlexDirection.Row;
-            root_child0.StyleMaxWidth = 100;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child0_child0 = new CSSNode();
-            root_child0_child0.FlexGrow = 1;
-            root_child0_child0.StyleHeight = 20;
-            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(200, 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(20, 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(20, root_child0_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(200, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(100, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(100, root_child0.LayoutWidth);
-            Assert.AreEqual(20, 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(20, root_child0_child0.LayoutHeight);
-        }
-
-        [Test]
-        public void Test_flex_grow_within_constrained_max_width()
-        {
-            CSSNode root = new CSSNode();
-            root.StyleWidth = 200;
-            root.StyleHeight = 100;
-
-            CSSNode root_child0 = new CSSNode();
-            root_child0.FlexDirection = CSSFlexDirection.Row;
-            root_child0.StyleMaxWidth = 300;
-            root.Insert(0, root_child0);
-
-            CSSNode root_child0_child0 = new CSSNode();
-            root_child0_child0.FlexGrow = 1;
-            root_child0_child0.StyleHeight = 20;
-            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(200, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(200, root_child0.LayoutWidth);
-            Assert.AreEqual(20, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0_child0.LayoutX);
-            Assert.AreEqual(0, root_child0_child0.LayoutY);
-            Assert.AreEqual(200, root_child0_child0.LayoutWidth);
-            Assert.AreEqual(20, root_child0_child0.LayoutHeight);
-
-            root.StyleDirection = CSSDirection.RightToLeft;
-            root.CalculateLayout();
-
-            Assert.AreEqual(0, root.LayoutX);
-            Assert.AreEqual(0, root.LayoutY);
-            Assert.AreEqual(200, root.LayoutWidth);
-            Assert.AreEqual(100, root.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0.LayoutX);
-            Assert.AreEqual(0, root_child0.LayoutY);
-            Assert.AreEqual(200, root_child0.LayoutWidth);
-            Assert.AreEqual(20, root_child0.LayoutHeight);
-
-            Assert.AreEqual(0, root_child0_child0.LayoutX);
-            Assert.AreEqual(0, root_child0_child0.LayoutY);
-            Assert.AreEqual(200, root_child0_child0.LayoutWidth);
-            Assert.AreEqual(20, root_child0_child0.LayoutHeight);
-        }
-
-    }
-}

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);
-        }
-
-    }
-}

csharp/tests/Facebook.Yoga/YGAbsolutePositionTest.cs

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

csharp/tests/Facebook.Yoga/YGAlignContentTest.cs

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

csharp/tests/Facebook.Yoga/YGAlignItemsTest.cs

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

csharp/tests/Facebook.Yoga/YGAlignSelfTest.cs

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

csharp/tests/Facebook.Yoga/YGBorderTest.cs

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

csharp/tests/Facebook.Yoga/YGFlexDirectionTest.cs

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

csharp/tests/Facebook.Yoga/YGFlexTest.cs

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

csharp/tests/Facebook.Yoga/YGFlexWrapTest.cs

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

csharp/tests/Facebook.Yoga/YGJustifyContentTest.cs

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

csharp/tests/Facebook.Yoga/YGMarginTest.cs

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

csharp/tests/Facebook.Yoga/YGMinMaxDimensionTest.cs

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

csharp/tests/Facebook.Yoga/YGPaddingTest.cs

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

csharp/tests/Facebook.Yoga/YGRoundingTest.cs

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

csharp/tests/Facebook.Yoga/YogaNodeCreateTest.cs

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

csharp/tests/Facebook.Yoga/YogaNodeTest.cs

@@ -11,18 +11,18 @@ using NUnit.Framework;
 using System;
 
 /**
- * Tests for {@link CSSNode}.
+ * Tests for {@link YogaNode}.
  */
-namespace Facebook.CSSLayout
+namespace Facebook.Yoga
 {
     [TestFixture]
-    public class CSSNodeTest
+    public class YogaNodeTest
     {
         [Test]
         public void TestAddChildGetParent()
         {
-            CSSNode parent = new CSSNode();
-            CSSNode child = new CSSNode();
+            YogaNode parent = new YogaNode();
+            YogaNode child = new YogaNode();
 
             Assert.IsNull(child.Parent);
             Assert.AreEqual(0, parent.Count);
@@ -42,22 +42,22 @@ namespace Facebook.CSSLayout
         [Test]
         public void TestChildren()
         {
-            CSSNode parent = new CSSNode();
-            foreach (CSSNode node in parent) {
+            YogaNode parent = new YogaNode();
+            foreach (YogaNode node in parent) {
                 Assert.Fail(node.ToString());
             }
 
-            CSSNode child0 = new CSSNode();
+            YogaNode child0 = new YogaNode();
             Assert.AreEqual(-1, parent.IndexOf(child0));
             parent.Insert(0, child0);
-            foreach (CSSNode node in parent) {
+            foreach (YogaNode node in parent) {
                 Assert.AreEqual(0, parent.IndexOf(node));
             }
 
-            CSSNode child1 = new CSSNode();
+            YogaNode child1 = new YogaNode();
             parent.Insert(1, child1);
             int index = 0;
-            foreach (CSSNode node in parent) {
+            foreach (YogaNode node in parent) {
                 Assert.AreEqual(index++, parent.IndexOf(node));
             }
 
@@ -76,7 +76,7 @@ namespace Facebook.CSSLayout
         [ExpectedException("System.NullReferenceException")]
         public void TestRemoveAtFromEmpty()
         {
-            CSSNode parent = new CSSNode();
+            YogaNode parent = new YogaNode();
             parent.RemoveAt(0);
         }
 
@@ -84,8 +84,8 @@ namespace Facebook.CSSLayout
         [ExpectedException("System.ArgumentOutOfRangeException")]
         public void TestRemoveAtOutOfRange()
         {
-            CSSNode parent = new CSSNode();
-            CSSNode child = new CSSNode();
+            YogaNode parent = new YogaNode();
+            YogaNode child = new YogaNode();
             parent.Insert(0, child);
             parent.RemoveAt(1);
         }
@@ -94,9 +94,9 @@ namespace Facebook.CSSLayout
         [ExpectedException("System.InvalidOperationException")]
         public void TestCannotAddChildToMultipleParents()
         {
-            CSSNode parent1 = new CSSNode();
-            CSSNode parent2 = new CSSNode();
-            CSSNode child = new CSSNode();
+            YogaNode parent1 = new YogaNode();
+            YogaNode parent2 = new YogaNode();
+            YogaNode child = new YogaNode();
 
             parent1.Insert(0, child);
             parent2.Insert(0, child);
@@ -105,19 +105,19 @@ namespace Facebook.CSSLayout
         [Test]
         public void TestReset()
         {
-            int instanceCount = CSSNode.GetInstanceCount();
-            CSSNode node = new CSSNode();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            int instanceCount = YogaNode.GetInstanceCount();
+            YogaNode node = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
             node.Reset();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
         }
 
         [Test]
         [ExpectedException("System.InvalidOperationException")]
         public void TestResetParent()
         {
-            CSSNode parent = new CSSNode();
-            CSSNode child = new CSSNode();
+            YogaNode parent = new YogaNode();
+            YogaNode child = new YogaNode();
             parent.Insert(0, child);
             parent.Reset();
         }
@@ -126,8 +126,8 @@ namespace Facebook.CSSLayout
         [ExpectedException("System.InvalidOperationException")]
         public void TestResetChild()
         {
-            CSSNode parent = new CSSNode();
-            CSSNode child = new CSSNode();
+            YogaNode parent = new YogaNode();
+            YogaNode child = new YogaNode();
             parent.Insert(0, child);
             child.Reset();
         }
@@ -135,24 +135,24 @@ namespace Facebook.CSSLayout
         [Test]
         public void TestClear()
         {
-            int instanceCount = CSSNode.GetInstanceCount();
-            CSSNode parent = new CSSNode();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
-            CSSNode child = new CSSNode();
-            Assert.AreEqual(instanceCount + 2, CSSNode.GetInstanceCount());
+            int instanceCount = YogaNode.GetInstanceCount();
+            YogaNode parent = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
+            YogaNode child = new YogaNode();
+            Assert.AreEqual(instanceCount + 2, YogaNode.GetInstanceCount());
             parent.Insert(0, child);
             Assert.AreEqual(1, parent.Count);
             Assert.AreEqual(parent, child.Parent);
             parent.Clear();
             Assert.AreEqual(0, parent.Count);
             Assert.IsNull(child.Parent);
-            Assert.AreEqual(instanceCount + 2, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount + 2, YogaNode.GetInstanceCount());
         }
 
         [Test]
         public void TestMeasureFunc()
         {
-            CSSNode node = new CSSNode();
+            YogaNode node = new YogaNode();
             node.SetMeasureFunction((_, width, widthMode, height, heightMode) => {
                 return MeasureOutput.Make(100, 150);
             });
@@ -164,7 +164,7 @@ namespace Facebook.CSSLayout
         [Test]
         public void TestMeasureFuncWithFloat()
         {
-            CSSNode node = new CSSNode();
+            YogaNode node = new YogaNode();
             node.SetMeasureFunction((_, width, widthMode, height, heightMode) => {
                 return MeasureOutput.Make(123.4f, 81.7f);
             });
@@ -177,11 +177,11 @@ namespace Facebook.CSSLayout
         [ExpectedException("System.InvalidOperationException")]
         public void TestChildWithMeasureFunc()
         {
-            CSSNode node = new CSSNode();
+            YogaNode node = new YogaNode();
             node.SetMeasureFunction((_, width, widthMode, height, heightMode) => {
                 return MeasureOutput.Make(100, 150);
             });
-            CSSNode child = new CSSNode();
+            YogaNode child = new YogaNode();
             node.Insert(0, child);
         }
 
@@ -189,8 +189,8 @@ namespace Facebook.CSSLayout
         [ExpectedException("System.InvalidOperationException")]
         public void TestMeasureFuncWithChild()
         {
-            CSSNode node = new CSSNode();
-            CSSNode child = new CSSNode();
+            YogaNode node = new YogaNode();
+            YogaNode child = new YogaNode();
             node.Insert(0, child);
             node.SetMeasureFunction((_, width, widthMode, height, heightMode) => {
                 return MeasureOutput.Make(100, 150);
@@ -200,43 +200,56 @@ namespace Facebook.CSSLayout
         [Test]
         public void TestPrint()
         {
-            CSSNode parent = new CSSNode();
-            parent.StyleWidth = 100;
-            parent.StyleHeight = 120;
-            CSSNode child0 = new CSSNode();
-            child0.StyleWidth = 30;
-            child0.StyleHeight = 40;
-            CSSNode child1 = new CSSNode();
-            child1.StyleWidth = 35;
-            child1.StyleHeight = 45;
+            YogaNode parent = new YogaNode();
+            parent.Width = 100;
+            parent.Height = 120;
+            YogaNode child0 = new YogaNode();
+            child0.Width = 30;
+            child0.Height = 40;
+            YogaNode child1 = new YogaNode();
+            child1.Width = 35;
+            child1.Height = 45;
             parent.Insert(0, child0);
             parent.Insert(0, child1);
             parent.CalculateLayout();
             Assert.AreEqual(parent.Print(), "{layout: {width: 100, height: 120, top: 0, left: 0}, flexDirection: 'column', alignItems: 'stretch', flexGrow: 0, flexShrink: 0, overflow: 'visible', width: 100, height: 120, children: [\n  {layout: {width: 35, height: 45, top: 0, left: 0}, flexDirection: 'column', alignItems: 'stretch', flexGrow: 0, flexShrink: 0, overflow: 'visible', width: 35, height: 45, },\n  {layout: {width: 30, height: 40, top: 45, left: 0}, flexDirection: 'column', alignItems: 'stretch', flexGrow: 0, flexShrink: 0, overflow: 'visible', width: 30, height: 40, },\n]},\n");
         }
 
+        [Test]
+        public void TestCopyStyle()
+        {
+            YogaNode node0 = new YogaNode();
+            Assert.IsTrue(YogaConstants.IsUndefined(node0.MaxHeight));
+
+            YogaNode node1 = new YogaNode();
+            node1.MaxHeight = 100;
+
+            node0.CopyStyle(node1);
+            Assert.AreEqual(100, node0.MaxHeight);
+        }
+
+#if !UNITY_EDITOR
         private void ForceGC()
         {
             GC.Collect(GC.MaxGeneration);
             GC.WaitForPendingFinalizers();
         }
 
-#if !UNITY_EDITOR
         [Test]
         public void TestDestructor()
         {
             ForceGC();
-            int instanceCount = CSSNode.GetInstanceCount();
+            int instanceCount = YogaNode.GetInstanceCount();
             TestDestructorForGC(instanceCount);
             ForceGC();
-            Assert.AreEqual(instanceCount, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount, YogaNode.GetInstanceCount());
         }
 
         private void TestDestructorForGC(int instanceCount)
         {
-            CSSNode node = new CSSNode();
+            YogaNode node = new YogaNode();
             Assert.IsNotNull(node);
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
             node = null;
         }
 
@@ -244,32 +257,32 @@ namespace Facebook.CSSLayout
         public void TestDestructorWithChildren()
         {
             ForceGC();
-            int instanceCount = CSSNode.GetInstanceCount();
+            int instanceCount = YogaNode.GetInstanceCount();
             TestDestructorWithChildrenForGC1(instanceCount);
             ForceGC();
-            Assert.AreEqual(instanceCount, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount, YogaNode.GetInstanceCount());
         }
 
         private void TestDestructorWithChildrenForGC1(int instanceCount)
         {
-            CSSNode node = new CSSNode();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            YogaNode node = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
 
             TestDestructorWithChildrenForGC2(node, instanceCount + 1);
             ForceGC();
-            Assert.AreEqual(instanceCount + 2, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount + 2, YogaNode.GetInstanceCount());
 
             TestDestructorWithChildrenForGC2(node, instanceCount + 2);
             ForceGC();
-            Assert.AreEqual(instanceCount + 3, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount + 3, YogaNode.GetInstanceCount());
 
             node = null;
         }
 
-        private void TestDestructorWithChildrenForGC2(CSSNode parent, int instanceCount)
+        private void TestDestructorWithChildrenForGC2(YogaNode parent, int instanceCount)
         {
-            CSSNode child = new CSSNode();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            YogaNode child = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
 
             parent.Insert(0, child);
             child = null;
@@ -279,21 +292,21 @@ namespace Facebook.CSSLayout
         public void TestParentDestructor()
         {
             ForceGC();
-            int instanceCount = CSSNode.GetInstanceCount();
-            CSSNode child = new CSSNode();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            int instanceCount = YogaNode.GetInstanceCount();
+            YogaNode child = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
 
             TestParentDestructorForGC(child, instanceCount + 1);
             ForceGC();
 
             Assert.IsNull(child.Parent);
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
         }
 
-        private void TestParentDestructorForGC(CSSNode child, int instanceCount)
+        private void TestParentDestructorForGC(YogaNode child, int instanceCount)
         {
-            CSSNode parent = new CSSNode();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            YogaNode parent = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
             parent.Insert(0, child);
         }
 
@@ -301,22 +314,22 @@ namespace Facebook.CSSLayout
         public void TestClearWithChildDestructor()
         {
             ForceGC();
-            int instanceCount = CSSNode.GetInstanceCount();
-            CSSNode node = new CSSNode();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            int instanceCount = YogaNode.GetInstanceCount();
+            YogaNode node = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
             TestClearWithChildDestructorForGC(node, instanceCount + 1);
             ForceGC();
-            Assert.AreEqual(instanceCount + 2, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount + 2, YogaNode.GetInstanceCount());
             node.Clear();
             Assert.AreEqual(0, node.Count);
             ForceGC();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
         }
 
-        private void TestClearWithChildDestructorForGC(CSSNode parent, int instanceCount)
+        private void TestClearWithChildDestructorForGC(YogaNode parent, int instanceCount)
         {
-            CSSNode child = new CSSNode();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            YogaNode child = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
             parent.Insert(0, child);
         }
 
@@ -324,20 +337,20 @@ namespace Facebook.CSSLayout
         public void TestMeasureFuncWithDestructor()
         {
             ForceGC();
-            int instanceCount = CSSNode.GetInstanceCount();
-            CSSNode parent = new CSSNode();
-            Assert.AreEqual(instanceCount + 1, CSSNode.GetInstanceCount());
+            int instanceCount = YogaNode.GetInstanceCount();
+            YogaNode parent = new YogaNode();
+            Assert.AreEqual(instanceCount + 1, YogaNode.GetInstanceCount());
             TestMeasureFuncWithDestructorForGC(parent);
             ForceGC();
-            Assert.AreEqual(instanceCount + 2, CSSNode.GetInstanceCount());
+            Assert.AreEqual(instanceCount + 2, YogaNode.GetInstanceCount());
             parent.CalculateLayout();
             Assert.AreEqual(120, (int)parent.LayoutWidth);
             Assert.AreEqual(130, (int)parent.LayoutHeight);
         }
 
-        private void TestMeasureFuncWithDestructorForGC(CSSNode parent)
+        private void TestMeasureFuncWithDestructorForGC(YogaNode parent)
         {
-            CSSNode child = new CSSNode();
+            YogaNode child = new YogaNode();
             parent.Insert(0, child);
             child.SetMeasureFunction((_, width, widthMode, height, heightMode) => {
                 return MeasureOutput.Make(120, 130);

csharp/tests/Facebook.Yoga/test_macos.sh

@@ -28,6 +28,6 @@ if [ -d $NUNIT \
   rm NUnit-2.6.4.zip
 fi
 
-clang -g -Wall -Wextra -dynamiclib -o libCSSLayout.dylib -I../../.. ../../../CSSLayout/*.c ../../CSSLayout/CSSInterop.cpp
-mcs -debug -t:library -r:$NUNIT/nunit.framework.dll -out:CSSLayoutTest.dll *.cs ../../../csharp/Facebook.CSSLayout/*cs
-MONO_PATH=$NUNIT mono --arch=64 --debug $NUNIT/nunit-console.exe CSSLayoutTest.dll
+clang -g -Wall -Wextra -dynamiclib -o libyoga.dylib -I../../.. ../../../CSSLayout/*.c ../../Yoga/YGInterop.cpp
+mcs -debug -t:library -r:$NUNIT/nunit.framework.dll -out:YogaTest.dll *.cs ../../../csharp/Facebook.Yoga/*cs
+MONO_PATH=$NUNIT mono --arch=64 --debug $NUNIT/nunit-console.exe YogaTest.dll

enums.py

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