automated-tests/src/dali-toolkit-third-party/yoga/YGMarginTest.cpp

   1 /**
   2  * Copyright (c) 2014-present, Facebook, Inc.
   3  *
   4  * This source code is licensed under the MIT license found in the
   5  * LICENSE file in the root directory of this source tree.
   6  */
   7
   8 // @Generated by gentest/gentest.rb from gentest/fixtures/YGMarginTest.html
   9
  10 #include <gtest/gtest.h>
  11 #include <yoga/Yoga.h>
  12
  13 TEST(YogaTest, margin_start) {
  14   const YGConfigRef config = YGConfigNew();
  15
  16   const YGNodeRef root = YGNodeNewWithConfig(config);
  17   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
  18   YGNodeStyleSetWidth(root, 100);
  19   YGNodeStyleSetHeight(root, 100);
  20
  21   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
  22   YGNodeStyleSetMargin(root_child0, YGEdgeStart, 10);
  23   YGNodeStyleSetWidth(root_child0, 10);
  24   YGNodeInsertChild(root, root_child0, 0);
  25   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
  26
  27   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
  28   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
  29   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
  30   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
  31
  32   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetLeft(root_child0));
  33   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
  34   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetWidth(root_child0));
  35   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
  36
  37   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
  38
  39   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
  40   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
  41   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
  42   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
  43
  44   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetLeft(root_child0));
  45   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
  46   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetWidth(root_child0));
  47   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
  48
  49   YGNodeFreeRecursive(root);
  50
  51   YGConfigFree(config);
  52 }
  53
  54 TEST(YogaTest, margin_top) {
  55   const YGConfigRef config = YGConfigNew();
  56
  57   const YGNodeRef root = YGNodeNewWithConfig(config);
  58   YGNodeStyleSetWidth(root, 100);
  59   YGNodeStyleSetHeight(root, 100);
  60
  61   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
  62   YGNodeStyleSetMargin(root_child0, YGEdgeTop, 10);
  63   YGNodeStyleSetHeight(root_child0, 10);
  64   YGNodeInsertChild(root, root_child0, 0);
  65   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
  66
  67   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
  68   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
  69   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
  70   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
  71
  72   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
  73   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0));
  74   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
  75   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0));
  76
  77   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
  78
  79   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
  80   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
  81   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
  82   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
  83
  84   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
  85   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0));
  86   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
  87   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0));
  88
  89   YGNodeFreeRecursive(root);
  90
  91   YGConfigFree(config);
  92 }
  93
  94 TEST(YogaTest, margin_end) {
  95   const YGConfigRef config = YGConfigNew();
  96
  97   const YGNodeRef root = YGNodeNewWithConfig(config);
  98   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
  99   YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd);
 100   YGNodeStyleSetWidth(root, 100);
 101   YGNodeStyleSetHeight(root, 100);
 102
 103   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 104   YGNodeStyleSetMargin(root_child0, YGEdgeEnd, 10);
 105   YGNodeStyleSetWidth(root_child0, 10);
 106   YGNodeInsertChild(root, root_child0, 0);
 107   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 108
 109   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 110   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 111   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 112   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 113
 114   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetLeft(root_child0));
 115   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 116   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetWidth(root_child0));
 117   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 118
 119   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 120
 121   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 122   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 123   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 124   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 125
 126   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetLeft(root_child0));
 127   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 128   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetWidth(root_child0));
 129   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 130
 131   YGNodeFreeRecursive(root);
 132
 133   YGConfigFree(config);
 134 }
 135
 136 TEST(YogaTest, margin_bottom) {
 137   const YGConfigRef config = YGConfigNew();
 138
 139   const YGNodeRef root = YGNodeNewWithConfig(config);
 140   YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd);
 141   YGNodeStyleSetWidth(root, 100);
 142   YGNodeStyleSetHeight(root, 100);
 143
 144   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 145   YGNodeStyleSetMargin(root_child0, YGEdgeBottom, 10);
 146   YGNodeStyleSetHeight(root_child0, 10);
 147   YGNodeInsertChild(root, root_child0, 0);
 148   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 149
 150   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 151   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 152   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 153   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 154
 155   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 156   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetTop(root_child0));
 157   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
 158   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0));
 159
 160   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 161
 162   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 163   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 164   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 165   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 166
 167   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 168   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetTop(root_child0));
 169   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
 170   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0));
 171
 172   YGNodeFreeRecursive(root);
 173
 174   YGConfigFree(config);
 175 }
 176
 177 TEST(YogaTest, margin_and_flex_row) {
 178   const YGConfigRef config = YGConfigNew();
 179
 180   const YGNodeRef root = YGNodeNewWithConfig(config);
 181   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 182   YGNodeStyleSetWidth(root, 100);
 183   YGNodeStyleSetHeight(root, 100);
 184
 185   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 186   YGNodeStyleSetFlexGrow(root_child0, 1);
 187   YGNodeStyleSetMargin(root_child0, YGEdgeStart, 10);
 188   YGNodeStyleSetMargin(root_child0, YGEdgeEnd, 10);
 189   YGNodeInsertChild(root, root_child0, 0);
 190   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 191
 192   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 193   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 194   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 195   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 196
 197   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetLeft(root_child0));
 198   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 199   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetWidth(root_child0));
 200   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 201
 202   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 203
 204   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 205   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 206   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 207   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 208
 209   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetLeft(root_child0));
 210   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 211   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetWidth(root_child0));
 212   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 213
 214   YGNodeFreeRecursive(root);
 215
 216   YGConfigFree(config);
 217 }
 218
 219 TEST(YogaTest, margin_and_flex_column) {
 220   const YGConfigRef config = YGConfigNew();
 221
 222   const YGNodeRef root = YGNodeNewWithConfig(config);
 223   YGNodeStyleSetWidth(root, 100);
 224   YGNodeStyleSetHeight(root, 100);
 225
 226   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 227   YGNodeStyleSetFlexGrow(root_child0, 1);
 228   YGNodeStyleSetMargin(root_child0, YGEdgeTop, 10);
 229   YGNodeStyleSetMargin(root_child0, YGEdgeBottom, 10);
 230   YGNodeInsertChild(root, root_child0, 0);
 231   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 232
 233   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 234   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 235   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 236   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 237
 238   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 239   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0));
 240   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
 241   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetHeight(root_child0));
 242
 243   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 244
 245   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 246   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 247   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 248   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 249
 250   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 251   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0));
 252   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
 253   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetHeight(root_child0));
 254
 255   YGNodeFreeRecursive(root);
 256
 257   YGConfigFree(config);
 258 }
 259
 260 TEST(YogaTest, margin_and_stretch_row) {
 261   const YGConfigRef config = YGConfigNew();
 262
 263   const YGNodeRef root = YGNodeNewWithConfig(config);
 264   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 265   YGNodeStyleSetWidth(root, 100);
 266   YGNodeStyleSetHeight(root, 100);
 267
 268   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 269   YGNodeStyleSetFlexGrow(root_child0, 1);
 270   YGNodeStyleSetMargin(root_child0, YGEdgeTop, 10);
 271   YGNodeStyleSetMargin(root_child0, YGEdgeBottom, 10);
 272   YGNodeInsertChild(root, root_child0, 0);
 273   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 274
 275   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 276   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 277   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 278   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 279
 280   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 281   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0));
 282   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
 283   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetHeight(root_child0));
 284
 285   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 286
 287   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 288   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 289   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 290   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 291
 292   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 293   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0));
 294   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
 295   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetHeight(root_child0));
 296
 297   YGNodeFreeRecursive(root);
 298
 299   YGConfigFree(config);
 300 }
 301
 302 TEST(YogaTest, margin_and_stretch_column) {
 303   const YGConfigRef config = YGConfigNew();
 304
 305   const YGNodeRef root = YGNodeNewWithConfig(config);
 306   YGNodeStyleSetWidth(root, 100);
 307   YGNodeStyleSetHeight(root, 100);
 308
 309   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 310   YGNodeStyleSetFlexGrow(root_child0, 1);
 311   YGNodeStyleSetMargin(root_child0, YGEdgeStart, 10);
 312   YGNodeStyleSetMargin(root_child0, YGEdgeEnd, 10);
 313   YGNodeInsertChild(root, root_child0, 0);
 314   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 315
 316   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 317   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 318   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 319   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 320
 321   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetLeft(root_child0));
 322   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 323   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetWidth(root_child0));
 324   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 325
 326   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 327
 328   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 329   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 330   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 331   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 332
 333   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetLeft(root_child0));
 334   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 335   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetWidth(root_child0));
 336   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 337
 338   YGNodeFreeRecursive(root);
 339
 340   YGConfigFree(config);
 341 }
 342
 343 TEST(YogaTest, margin_with_sibling_row) {
 344   const YGConfigRef config = YGConfigNew();
 345
 346   const YGNodeRef root = YGNodeNewWithConfig(config);
 347   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 348   YGNodeStyleSetWidth(root, 100);
 349   YGNodeStyleSetHeight(root, 100);
 350
 351   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 352   YGNodeStyleSetFlexGrow(root_child0, 1);
 353   YGNodeStyleSetMargin(root_child0, YGEdgeEnd, 10);
 354   YGNodeInsertChild(root, root_child0, 0);
 355
 356   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 357   YGNodeStyleSetFlexGrow(root_child1, 1);
 358   YGNodeInsertChild(root, root_child1, 1);
 359   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 360
 361   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 362   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 363   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 364   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 365
 366   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 367   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 368   ASSERT_FLOAT_EQ(45, YGNodeLayoutGetWidth(root_child0));
 369   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 370
 371   ASSERT_FLOAT_EQ(55, YGNodeLayoutGetLeft(root_child1));
 372   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 373   ASSERT_FLOAT_EQ(45, YGNodeLayoutGetWidth(root_child1));
 374   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
 375
 376   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 377
 378   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 379   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 380   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 381   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 382
 383   ASSERT_FLOAT_EQ(55, YGNodeLayoutGetLeft(root_child0));
 384   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 385   ASSERT_FLOAT_EQ(45, YGNodeLayoutGetWidth(root_child0));
 386   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 387
 388   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 389   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 390   ASSERT_FLOAT_EQ(45, YGNodeLayoutGetWidth(root_child1));
 391   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
 392
 393   YGNodeFreeRecursive(root);
 394
 395   YGConfigFree(config);
 396 }
 397
 398 TEST(YogaTest, margin_with_sibling_column) {
 399   const YGConfigRef config = YGConfigNew();
 400
 401   const YGNodeRef root = YGNodeNewWithConfig(config);
 402   YGNodeStyleSetWidth(root, 100);
 403   YGNodeStyleSetHeight(root, 100);
 404
 405   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 406   YGNodeStyleSetFlexGrow(root_child0, 1);
 407   YGNodeStyleSetMargin(root_child0, YGEdgeBottom, 10);
 408   YGNodeInsertChild(root, root_child0, 0);
 409
 410   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 411   YGNodeStyleSetFlexGrow(root_child1, 1);
 412   YGNodeInsertChild(root, root_child1, 1);
 413   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 414
 415   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 416   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 417   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 418   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 419
 420   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 421   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 422   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
 423   ASSERT_FLOAT_EQ(45, YGNodeLayoutGetHeight(root_child0));
 424
 425   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 426   ASSERT_FLOAT_EQ(55, YGNodeLayoutGetTop(root_child1));
 427   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child1));
 428   ASSERT_FLOAT_EQ(45, YGNodeLayoutGetHeight(root_child1));
 429
 430   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 431
 432   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 433   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 434   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
 435   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 436
 437   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 438   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 439   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
 440   ASSERT_FLOAT_EQ(45, YGNodeLayoutGetHeight(root_child0));
 441
 442   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 443   ASSERT_FLOAT_EQ(55, YGNodeLayoutGetTop(root_child1));
 444   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child1));
 445   ASSERT_FLOAT_EQ(45, YGNodeLayoutGetHeight(root_child1));
 446
 447   YGNodeFreeRecursive(root);
 448
 449   YGConfigFree(config);
 450 }
 451
 452 TEST(YogaTest, margin_auto_bottom) {
 453   const YGConfigRef config = YGConfigNew();
 454
 455   const YGNodeRef root = YGNodeNewWithConfig(config);
 456   YGNodeStyleSetAlignItems(root, YGAlignCenter);
 457   YGNodeStyleSetWidth(root, 200);
 458   YGNodeStyleSetHeight(root, 200);
 459
 460   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 461   YGNodeStyleSetMarginAuto(root_child0, YGEdgeBottom);
 462   YGNodeStyleSetWidth(root_child0, 50);
 463   YGNodeStyleSetHeight(root_child0, 50);
 464   YGNodeInsertChild(root, root_child0, 0);
 465
 466   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 467   YGNodeStyleSetWidth(root_child1, 50);
 468   YGNodeStyleSetHeight(root_child1, 50);
 469   YGNodeInsertChild(root, root_child1, 1);
 470   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 471
 472   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 473   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 474   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 475   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 476
 477   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 478   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 479   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 480   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 481
 482   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
 483   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
 484   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 485   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 486
 487   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 488
 489   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 490   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 491   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 492   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 493
 494   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 495   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 496   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 497   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 498
 499   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
 500   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
 501   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 502   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 503
 504   YGNodeFreeRecursive(root);
 505
 506   YGConfigFree(config);
 507 }
 508
 509 TEST(YogaTest, margin_auto_top) {
 510   const YGConfigRef config = YGConfigNew();
 511
 512   const YGNodeRef root = YGNodeNewWithConfig(config);
 513   YGNodeStyleSetAlignItems(root, YGAlignCenter);
 514   YGNodeStyleSetWidth(root, 200);
 515   YGNodeStyleSetHeight(root, 200);
 516
 517   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 518   YGNodeStyleSetMarginAuto(root_child0, YGEdgeTop);
 519   YGNodeStyleSetWidth(root_child0, 50);
 520   YGNodeStyleSetHeight(root_child0, 50);
 521   YGNodeInsertChild(root, root_child0, 0);
 522
 523   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 524   YGNodeStyleSetWidth(root_child1, 50);
 525   YGNodeStyleSetHeight(root_child1, 50);
 526   YGNodeInsertChild(root, root_child1, 1);
 527   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 528
 529   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 530   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 531   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 532   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 533
 534   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 535   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetTop(root_child0));
 536   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 537   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 538
 539   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
 540   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
 541   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 542   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 543
 544   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 545
 546   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 547   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 548   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 549   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 550
 551   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 552   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetTop(root_child0));
 553   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 554   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 555
 556   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
 557   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
 558   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 559   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 560
 561   YGNodeFreeRecursive(root);
 562
 563   YGConfigFree(config);
 564 }
 565
 566 TEST(YogaTest, margin_auto_bottom_and_top) {
 567   const YGConfigRef config = YGConfigNew();
 568
 569   const YGNodeRef root = YGNodeNewWithConfig(config);
 570   YGNodeStyleSetAlignItems(root, YGAlignCenter);
 571   YGNodeStyleSetWidth(root, 200);
 572   YGNodeStyleSetHeight(root, 200);
 573
 574   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 575   YGNodeStyleSetMarginAuto(root_child0, YGEdgeTop);
 576   YGNodeStyleSetMarginAuto(root_child0, YGEdgeBottom);
 577   YGNodeStyleSetWidth(root_child0, 50);
 578   YGNodeStyleSetHeight(root_child0, 50);
 579   YGNodeInsertChild(root, root_child0, 0);
 580
 581   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 582   YGNodeStyleSetWidth(root_child1, 50);
 583   YGNodeStyleSetHeight(root_child1, 50);
 584   YGNodeInsertChild(root, root_child1, 1);
 585   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 586
 587   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 588   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 589   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 590   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 591
 592   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 593   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child0));
 594   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 595   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 596
 597   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
 598   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
 599   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 600   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 601
 602   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 603
 604   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 605   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 606   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 607   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 608
 609   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 610   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child0));
 611   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 612   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 613
 614   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
 615   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
 616   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 617   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 618
 619   YGNodeFreeRecursive(root);
 620
 621   YGConfigFree(config);
 622 }
 623
 624 TEST(YogaTest, margin_auto_bottom_and_top_justify_center) {
 625   const YGConfigRef config = YGConfigNew();
 626
 627   const YGNodeRef root = YGNodeNewWithConfig(config);
 628   YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
 629   YGNodeStyleSetWidth(root, 200);
 630   YGNodeStyleSetHeight(root, 200);
 631
 632   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 633   YGNodeStyleSetMarginAuto(root_child0, YGEdgeTop);
 634   YGNodeStyleSetMarginAuto(root_child0, YGEdgeBottom);
 635   YGNodeStyleSetWidth(root_child0, 50);
 636   YGNodeStyleSetHeight(root_child0, 50);
 637   YGNodeInsertChild(root, root_child0, 0);
 638
 639   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 640   YGNodeStyleSetWidth(root_child1, 50);
 641   YGNodeStyleSetHeight(root_child1, 50);
 642   YGNodeInsertChild(root, root_child1, 1);
 643   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 644
 645   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 646   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 647   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 648   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 649
 650   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 651   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child0));
 652   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 653   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 654
 655   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 656   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
 657   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 658   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 659
 660   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 661
 662   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 663   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 664   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 665   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 666
 667   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0));
 668   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child0));
 669   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 670   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 671
 672   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
 673   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
 674   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 675   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 676
 677   YGNodeFreeRecursive(root);
 678
 679   YGConfigFree(config);
 680 }
 681
 682 TEST(YogaTest, margin_auto_mutiple_children_column) {
 683   const YGConfigRef config = YGConfigNew();
 684
 685   const YGNodeRef root = YGNodeNewWithConfig(config);
 686   YGNodeStyleSetAlignItems(root, YGAlignCenter);
 687   YGNodeStyleSetWidth(root, 200);
 688   YGNodeStyleSetHeight(root, 200);
 689
 690   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 691   YGNodeStyleSetMarginAuto(root_child0, YGEdgeTop);
 692   YGNodeStyleSetWidth(root_child0, 50);
 693   YGNodeStyleSetHeight(root_child0, 50);
 694   YGNodeInsertChild(root, root_child0, 0);
 695
 696   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 697   YGNodeStyleSetMarginAuto(root_child1, YGEdgeTop);
 698   YGNodeStyleSetWidth(root_child1, 50);
 699   YGNodeStyleSetHeight(root_child1, 50);
 700   YGNodeInsertChild(root, root_child1, 1);
 701
 702   const YGNodeRef root_child2 = YGNodeNewWithConfig(config);
 703   YGNodeStyleSetWidth(root_child2, 50);
 704   YGNodeStyleSetHeight(root_child2, 50);
 705   YGNodeInsertChild(root, root_child2, 2);
 706   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 707
 708   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 709   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 710   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 711   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 712
 713   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 714   ASSERT_FLOAT_EQ(25, YGNodeLayoutGetTop(root_child0));
 715   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 716   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 717
 718   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
 719   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetTop(root_child1));
 720   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 721   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 722
 723   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child2));
 724   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child2));
 725   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child2));
 726   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
 727
 728   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 729
 730   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 731   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 732   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 733   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 734
 735   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 736   ASSERT_FLOAT_EQ(25, YGNodeLayoutGetTop(root_child0));
 737   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 738   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 739
 740   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
 741   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetTop(root_child1));
 742   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 743   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 744
 745   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child2));
 746   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child2));
 747   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child2));
 748   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
 749
 750   YGNodeFreeRecursive(root);
 751
 752   YGConfigFree(config);
 753 }
 754
 755 TEST(YogaTest, margin_auto_mutiple_children_row) {
 756   const YGConfigRef config = YGConfigNew();
 757
 758   const YGNodeRef root = YGNodeNewWithConfig(config);
 759   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 760   YGNodeStyleSetAlignItems(root, YGAlignCenter);
 761   YGNodeStyleSetWidth(root, 200);
 762   YGNodeStyleSetHeight(root, 200);
 763
 764   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 765   YGNodeStyleSetMarginAuto(root_child0, YGEdgeRight);
 766   YGNodeStyleSetWidth(root_child0, 50);
 767   YGNodeStyleSetHeight(root_child0, 50);
 768   YGNodeInsertChild(root, root_child0, 0);
 769
 770   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 771   YGNodeStyleSetMarginAuto(root_child1, YGEdgeRight);
 772   YGNodeStyleSetWidth(root_child1, 50);
 773   YGNodeStyleSetHeight(root_child1, 50);
 774   YGNodeInsertChild(root, root_child1, 1);
 775
 776   const YGNodeRef root_child2 = YGNodeNewWithConfig(config);
 777   YGNodeStyleSetWidth(root_child2, 50);
 778   YGNodeStyleSetHeight(root_child2, 50);
 779   YGNodeInsertChild(root, root_child2, 2);
 780   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 781
 782   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 783   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 784   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 785   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 786
 787   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 788   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child0));
 789   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 790   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 791
 792   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
 793   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child1));
 794   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 795   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 796
 797   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child2));
 798   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child2));
 799   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child2));
 800   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
 801
 802   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 803
 804   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 805   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 806   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 807   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 808
 809   ASSERT_FLOAT_EQ(125, YGNodeLayoutGetLeft(root_child0));
 810   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child0));
 811   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 812   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 813
 814   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child1));
 815   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child1));
 816   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 817   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 818
 819   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child2));
 820   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child2));
 821   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child2));
 822   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
 823
 824   YGNodeFreeRecursive(root);
 825
 826   YGConfigFree(config);
 827 }
 828
 829 TEST(YogaTest, margin_auto_left_and_right_column) {
 830   const YGConfigRef config = YGConfigNew();
 831
 832   const YGNodeRef root = YGNodeNewWithConfig(config);
 833   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 834   YGNodeStyleSetAlignItems(root, YGAlignCenter);
 835   YGNodeStyleSetWidth(root, 200);
 836   YGNodeStyleSetHeight(root, 200);
 837
 838   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 839   YGNodeStyleSetMarginAuto(root_child0, YGEdgeLeft);
 840   YGNodeStyleSetMarginAuto(root_child0, YGEdgeRight);
 841   YGNodeStyleSetWidth(root_child0, 50);
 842   YGNodeStyleSetHeight(root_child0, 50);
 843   YGNodeInsertChild(root, root_child0, 0);
 844
 845   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 846   YGNodeStyleSetWidth(root_child1, 50);
 847   YGNodeStyleSetHeight(root_child1, 50);
 848   YGNodeInsertChild(root, root_child1, 1);
 849   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 850
 851   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 852   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 853   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 854   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 855
 856   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0));
 857   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child0));
 858   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 859   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 860
 861   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
 862   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child1));
 863   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 864   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 865
 866   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 867
 868   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 869   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 870   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 871   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 872
 873   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetLeft(root_child0));
 874   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child0));
 875   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 876   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 877
 878   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 879   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child1));
 880   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 881   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 882
 883   YGNodeFreeRecursive(root);
 884
 885   YGConfigFree(config);
 886 }
 887
 888 TEST(YogaTest, margin_auto_left_and_right) {
 889   const YGConfigRef config = YGConfigNew();
 890
 891   const YGNodeRef root = YGNodeNewWithConfig(config);
 892   YGNodeStyleSetWidth(root, 200);
 893   YGNodeStyleSetHeight(root, 200);
 894
 895   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 896   YGNodeStyleSetMarginAuto(root_child0, YGEdgeLeft);
 897   YGNodeStyleSetMarginAuto(root_child0, YGEdgeRight);
 898   YGNodeStyleSetWidth(root_child0, 50);
 899   YGNodeStyleSetHeight(root_child0, 50);
 900   YGNodeInsertChild(root, root_child0, 0);
 901
 902   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 903   YGNodeStyleSetWidth(root_child1, 50);
 904   YGNodeStyleSetHeight(root_child1, 50);
 905   YGNodeInsertChild(root, root_child1, 1);
 906   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 907
 908   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 909   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 910   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 911   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 912
 913   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 914   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 915   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 916   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 917
 918   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 919   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
 920   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 921   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 922
 923   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 924
 925   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 926   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 927   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 928   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 929
 930   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 931   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 932   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 933   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 934
 935   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
 936   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
 937   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 938   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 939
 940   YGNodeFreeRecursive(root);
 941
 942   YGConfigFree(config);
 943 }
 944
 945 TEST(YogaTest, margin_auto_start_and_end_column) {
 946   const YGConfigRef config = YGConfigNew();
 947
 948   const YGNodeRef root = YGNodeNewWithConfig(config);
 949   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 950   YGNodeStyleSetAlignItems(root, YGAlignCenter);
 951   YGNodeStyleSetWidth(root, 200);
 952   YGNodeStyleSetHeight(root, 200);
 953
 954   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 955   YGNodeStyleSetMarginAuto(root_child0, YGEdgeStart);
 956   YGNodeStyleSetMarginAuto(root_child0, YGEdgeEnd);
 957   YGNodeStyleSetWidth(root_child0, 50);
 958   YGNodeStyleSetHeight(root_child0, 50);
 959   YGNodeInsertChild(root, root_child0, 0);
 960
 961   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 962   YGNodeStyleSetWidth(root_child1, 50);
 963   YGNodeStyleSetHeight(root_child1, 50);
 964   YGNodeInsertChild(root, root_child1, 1);
 965   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 966
 967   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 968   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 969   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 970   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 971
 972   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0));
 973   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child0));
 974   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 975   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 976
 977   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
 978   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child1));
 979   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 980   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 981
 982   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 983
 984   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 985   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 986   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 987   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 988
 989   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetLeft(root_child0));
 990   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child0));
 991   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
 992   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 993
 994   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 995   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child1));
 996   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
 997   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
 998
 999   YGNodeFreeRecursive(root);
1000
1001   YGConfigFree(config);
1002 }
1003
1004 TEST(YogaTest, margin_auto_start_and_end) {
1005   const YGConfigRef config = YGConfigNew();
1006
1007   const YGNodeRef root = YGNodeNewWithConfig(config);
1008   YGNodeStyleSetWidth(root, 200);
1009   YGNodeStyleSetHeight(root, 200);
1010
1011   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1012   YGNodeStyleSetMarginAuto(root_child0, YGEdgeStart);
1013   YGNodeStyleSetMarginAuto(root_child0, YGEdgeEnd);
1014   YGNodeStyleSetWidth(root_child0, 50);
1015   YGNodeStyleSetHeight(root_child0, 50);
1016   YGNodeInsertChild(root, root_child0, 0);
1017
1018   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
1019   YGNodeStyleSetWidth(root_child1, 50);
1020   YGNodeStyleSetHeight(root_child1, 50);
1021   YGNodeInsertChild(root, root_child1, 1);
1022   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1023
1024   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1025   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1026   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1027   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1028
1029   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
1030   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1031   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1032   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1033
1034   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
1035   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
1036   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1037   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1038
1039   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1040
1041   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1042   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1043   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1044   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1045
1046   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
1047   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1048   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1049   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1050
1051   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
1052   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
1053   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1054   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1055
1056   YGNodeFreeRecursive(root);
1057
1058   YGConfigFree(config);
1059 }
1060
1061 TEST(YogaTest, margin_auto_left_and_right_column_and_center) {
1062   const YGConfigRef config = YGConfigNew();
1063
1064   const YGNodeRef root = YGNodeNewWithConfig(config);
1065   YGNodeStyleSetAlignItems(root, YGAlignCenter);
1066   YGNodeStyleSetWidth(root, 200);
1067   YGNodeStyleSetHeight(root, 200);
1068
1069   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1070   YGNodeStyleSetMarginAuto(root_child0, YGEdgeLeft);
1071   YGNodeStyleSetMarginAuto(root_child0, YGEdgeRight);
1072   YGNodeStyleSetWidth(root_child0, 50);
1073   YGNodeStyleSetHeight(root_child0, 50);
1074   YGNodeInsertChild(root, root_child0, 0);
1075
1076   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
1077   YGNodeStyleSetWidth(root_child1, 50);
1078   YGNodeStyleSetHeight(root_child1, 50);
1079   YGNodeInsertChild(root, root_child1, 1);
1080   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1081
1082   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1083   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1084   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1085   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1086
1087   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
1088   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1089   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1090   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1091
1092   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
1093   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
1094   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1095   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1096
1097   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1098
1099   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1100   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1101   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1102   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1103
1104   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
1105   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1106   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1107   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1108
1109   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
1110   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
1111   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1112   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1113
1114   YGNodeFreeRecursive(root);
1115
1116   YGConfigFree(config);
1117 }
1118
1119 TEST(YogaTest, margin_auto_left) {
1120   const YGConfigRef config = YGConfigNew();
1121
1122   const YGNodeRef root = YGNodeNewWithConfig(config);
1123   YGNodeStyleSetAlignItems(root, YGAlignCenter);
1124   YGNodeStyleSetWidth(root, 200);
1125   YGNodeStyleSetHeight(root, 200);
1126
1127   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1128   YGNodeStyleSetMarginAuto(root_child0, YGEdgeLeft);
1129   YGNodeStyleSetWidth(root_child0, 50);
1130   YGNodeStyleSetHeight(root_child0, 50);
1131   YGNodeInsertChild(root, root_child0, 0);
1132
1133   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
1134   YGNodeStyleSetWidth(root_child1, 50);
1135   YGNodeStyleSetHeight(root_child1, 50);
1136   YGNodeInsertChild(root, root_child1, 1);
1137   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1138
1139   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1140   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1141   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1142   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1143
1144   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0));
1145   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1146   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1147   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1148
1149   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
1150   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
1151   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1152   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1153
1154   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1155
1156   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1157   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1158   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1159   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1160
1161   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0));
1162   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1163   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1164   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1165
1166   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
1167   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
1168   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1169   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1170
1171   YGNodeFreeRecursive(root);
1172
1173   YGConfigFree(config);
1174 }
1175
1176 TEST(YogaTest, margin_auto_right) {
1177   const YGConfigRef config = YGConfigNew();
1178
1179   const YGNodeRef root = YGNodeNewWithConfig(config);
1180   YGNodeStyleSetAlignItems(root, YGAlignCenter);
1181   YGNodeStyleSetWidth(root, 200);
1182   YGNodeStyleSetHeight(root, 200);
1183
1184   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1185   YGNodeStyleSetMarginAuto(root_child0, YGEdgeRight);
1186   YGNodeStyleSetWidth(root_child0, 50);
1187   YGNodeStyleSetHeight(root_child0, 50);
1188   YGNodeInsertChild(root, root_child0, 0);
1189
1190   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
1191   YGNodeStyleSetWidth(root_child1, 50);
1192   YGNodeStyleSetHeight(root_child1, 50);
1193   YGNodeInsertChild(root, root_child1, 1);
1194   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1195
1196   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1197   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1198   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1199   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1200
1201   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
1202   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1203   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1204   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1205
1206   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
1207   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
1208   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1209   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1210
1211   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1212
1213   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1214   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1215   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1216   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1217
1218   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
1219   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1220   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1221   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1222
1223   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
1224   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
1225   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1226   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1227
1228   YGNodeFreeRecursive(root);
1229
1230   YGConfigFree(config);
1231 }
1232
1233 TEST(YogaTest, margin_auto_left_and_right_strech) {
1234   const YGConfigRef config = YGConfigNew();
1235
1236   const YGNodeRef root = YGNodeNewWithConfig(config);
1237   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
1238   YGNodeStyleSetWidth(root, 200);
1239   YGNodeStyleSetHeight(root, 200);
1240
1241   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1242   YGNodeStyleSetMarginAuto(root_child0, YGEdgeLeft);
1243   YGNodeStyleSetMarginAuto(root_child0, YGEdgeRight);
1244   YGNodeStyleSetWidth(root_child0, 50);
1245   YGNodeStyleSetHeight(root_child0, 50);
1246   YGNodeInsertChild(root, root_child0, 0);
1247
1248   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
1249   YGNodeStyleSetWidth(root_child1, 50);
1250   YGNodeStyleSetHeight(root_child1, 50);
1251   YGNodeInsertChild(root, root_child1, 1);
1252   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1253
1254   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1255   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1256   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1257   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1258
1259   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0));
1260   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1261   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1262   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1263
1264   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
1265   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
1266   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1267   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1268
1269   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1270
1271   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1272   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1273   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1274   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1275
1276   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetLeft(root_child0));
1277   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1278   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1279   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1280
1281   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
1282   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
1283   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1284   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1285
1286   YGNodeFreeRecursive(root);
1287
1288   YGConfigFree(config);
1289 }
1290
1291 TEST(YogaTest, margin_auto_top_and_bottom_strech) {
1292   const YGConfigRef config = YGConfigNew();
1293
1294   const YGNodeRef root = YGNodeNewWithConfig(config);
1295   YGNodeStyleSetWidth(root, 200);
1296   YGNodeStyleSetHeight(root, 200);
1297
1298   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1299   YGNodeStyleSetMarginAuto(root_child0, YGEdgeTop);
1300   YGNodeStyleSetMarginAuto(root_child0, YGEdgeBottom);
1301   YGNodeStyleSetWidth(root_child0, 50);
1302   YGNodeStyleSetHeight(root_child0, 50);
1303   YGNodeInsertChild(root, root_child0, 0);
1304
1305   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
1306   YGNodeStyleSetWidth(root_child1, 50);
1307   YGNodeStyleSetHeight(root_child1, 50);
1308   YGNodeInsertChild(root, root_child1, 1);
1309   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1310
1311   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1312   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1313   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1314   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1315
1316   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
1317   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child0));
1318   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1319   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1320
1321   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
1322   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
1323   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1324   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1325
1326   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1327
1328   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1329   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1330   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1331   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1332
1333   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0));
1334   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child0));
1335   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0));
1336   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1337
1338   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
1339   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
1340   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1341   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1342
1343   YGNodeFreeRecursive(root);
1344
1345   YGConfigFree(config);
1346 }
1347
1348 TEST(YogaTest, margin_should_not_be_part_of_max_height) {
1349   const YGConfigRef config = YGConfigNew();
1350
1351   const YGNodeRef root = YGNodeNewWithConfig(config);
1352   YGNodeStyleSetWidth(root, 250);
1353   YGNodeStyleSetHeight(root, 250);
1354
1355   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1356   YGNodeStyleSetMargin(root_child0, YGEdgeTop, 20);
1357   YGNodeStyleSetWidth(root_child0, 100);
1358   YGNodeStyleSetHeight(root_child0, 100);
1359   YGNodeStyleSetMaxHeight(root_child0, 100);
1360   YGNodeInsertChild(root, root_child0, 0);
1361   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1362
1363   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1364   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1365   ASSERT_FLOAT_EQ(250, YGNodeLayoutGetWidth(root));
1366   ASSERT_FLOAT_EQ(250, YGNodeLayoutGetHeight(root));
1367
1368   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
1369   ASSERT_FLOAT_EQ(20, YGNodeLayoutGetTop(root_child0));
1370   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
1371   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
1372
1373   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1374
1375   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1376   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1377   ASSERT_FLOAT_EQ(250, YGNodeLayoutGetWidth(root));
1378   ASSERT_FLOAT_EQ(250, YGNodeLayoutGetHeight(root));
1379
1380   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0));
1381   ASSERT_FLOAT_EQ(20, YGNodeLayoutGetTop(root_child0));
1382   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
1383   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
1384
1385   YGNodeFreeRecursive(root);
1386
1387   YGConfigFree(config);
1388 }
1389
1390 TEST(YogaTest, margin_should_not_be_part_of_max_width) {
1391   const YGConfigRef config = YGConfigNew();
1392
1393   const YGNodeRef root = YGNodeNewWithConfig(config);
1394   YGNodeStyleSetWidth(root, 250);
1395   YGNodeStyleSetHeight(root, 250);
1396
1397   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1398   YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 20);
1399   YGNodeStyleSetWidth(root_child0, 100);
1400   YGNodeStyleSetMaxWidth(root_child0, 100);
1401   YGNodeStyleSetHeight(root_child0, 100);
1402   YGNodeInsertChild(root, root_child0, 0);
1403   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1404
1405   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1406   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1407   ASSERT_FLOAT_EQ(250, YGNodeLayoutGetWidth(root));
1408   ASSERT_FLOAT_EQ(250, YGNodeLayoutGetHeight(root));
1409
1410   ASSERT_FLOAT_EQ(20, YGNodeLayoutGetLeft(root_child0));
1411   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1412   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
1413   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
1414
1415   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1416
1417   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1418   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1419   ASSERT_FLOAT_EQ(250, YGNodeLayoutGetWidth(root));
1420   ASSERT_FLOAT_EQ(250, YGNodeLayoutGetHeight(root));
1421
1422   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0));
1423   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1424   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
1425   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
1426
1427   YGNodeFreeRecursive(root);
1428
1429   YGConfigFree(config);
1430 }
1431
1432 TEST(YogaTest, margin_auto_left_right_child_bigger_than_parent) {
1433   const YGConfigRef config = YGConfigNew();
1434
1435   const YGNodeRef root = YGNodeNewWithConfig(config);
1436   YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
1437   YGNodeStyleSetWidth(root, 52);
1438   YGNodeStyleSetHeight(root, 52);
1439
1440   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1441   YGNodeStyleSetMarginAuto(root_child0, YGEdgeLeft);
1442   YGNodeStyleSetMarginAuto(root_child0, YGEdgeRight);
1443   YGNodeStyleSetWidth(root_child0, 72);
1444   YGNodeStyleSetHeight(root_child0, 72);
1445   YGNodeInsertChild(root, root_child0, 0);
1446   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1447
1448   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1449   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1450   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetWidth(root));
1451   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetHeight(root));
1452
1453   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
1454   ASSERT_FLOAT_EQ(-10, YGNodeLayoutGetTop(root_child0));
1455   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetWidth(root_child0));
1456   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetHeight(root_child0));
1457
1458   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1459
1460   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1461   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1462   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetWidth(root));
1463   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetHeight(root));
1464
1465   ASSERT_FLOAT_EQ(-20, YGNodeLayoutGetLeft(root_child0));
1466   ASSERT_FLOAT_EQ(-10, YGNodeLayoutGetTop(root_child0));
1467   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetWidth(root_child0));
1468   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetHeight(root_child0));
1469
1470   YGNodeFreeRecursive(root);
1471
1472   YGConfigFree(config);
1473 }
1474
1475 TEST(YogaTest, margin_auto_left_child_bigger_than_parent) {
1476   const YGConfigRef config = YGConfigNew();
1477
1478   const YGNodeRef root = YGNodeNewWithConfig(config);
1479   YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
1480   YGNodeStyleSetWidth(root, 52);
1481   YGNodeStyleSetHeight(root, 52);
1482
1483   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1484   YGNodeStyleSetMarginAuto(root_child0, YGEdgeLeft);
1485   YGNodeStyleSetWidth(root_child0, 72);
1486   YGNodeStyleSetHeight(root_child0, 72);
1487   YGNodeInsertChild(root, root_child0, 0);
1488   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1489
1490   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1491   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1492   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetWidth(root));
1493   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetHeight(root));
1494
1495   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
1496   ASSERT_FLOAT_EQ(-10, YGNodeLayoutGetTop(root_child0));
1497   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetWidth(root_child0));
1498   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetHeight(root_child0));
1499
1500   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1501
1502   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1503   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1504   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetWidth(root));
1505   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetHeight(root));
1506
1507   ASSERT_FLOAT_EQ(-20, YGNodeLayoutGetLeft(root_child0));
1508   ASSERT_FLOAT_EQ(-10, YGNodeLayoutGetTop(root_child0));
1509   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetWidth(root_child0));
1510   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetHeight(root_child0));
1511
1512   YGNodeFreeRecursive(root);
1513
1514   YGConfigFree(config);
1515 }
1516
1517 TEST(YogaTest, margin_fix_left_auto_right_child_bigger_than_parent) {
1518   const YGConfigRef config = YGConfigNew();
1519
1520   const YGNodeRef root = YGNodeNewWithConfig(config);
1521   YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
1522   YGNodeStyleSetWidth(root, 52);
1523   YGNodeStyleSetHeight(root, 52);
1524
1525   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1526   YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 10);
1527   YGNodeStyleSetMarginAuto(root_child0, YGEdgeRight);
1528   YGNodeStyleSetWidth(root_child0, 72);
1529   YGNodeStyleSetHeight(root_child0, 72);
1530   YGNodeInsertChild(root, root_child0, 0);
1531   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1532
1533   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1534   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1535   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetWidth(root));
1536   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetHeight(root));
1537
1538   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetLeft(root_child0));
1539   ASSERT_FLOAT_EQ(-10, YGNodeLayoutGetTop(root_child0));
1540   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetWidth(root_child0));
1541   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetHeight(root_child0));
1542
1543   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1544
1545   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1546   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1547   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetWidth(root));
1548   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetHeight(root));
1549
1550   ASSERT_FLOAT_EQ(-20, YGNodeLayoutGetLeft(root_child0));
1551   ASSERT_FLOAT_EQ(-10, YGNodeLayoutGetTop(root_child0));
1552   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetWidth(root_child0));
1553   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetHeight(root_child0));
1554
1555   YGNodeFreeRecursive(root);
1556
1557   YGConfigFree(config);
1558 }
1559
1560 TEST(YogaTest, margin_auto_left_fix_right_child_bigger_than_parent) {
1561   const YGConfigRef config = YGConfigNew();
1562
1563   const YGNodeRef root = YGNodeNewWithConfig(config);
1564   YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
1565   YGNodeStyleSetWidth(root, 52);
1566   YGNodeStyleSetHeight(root, 52);
1567
1568   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1569   YGNodeStyleSetMarginAuto(root_child0, YGEdgeLeft);
1570   YGNodeStyleSetMargin(root_child0, YGEdgeRight, 10);
1571   YGNodeStyleSetWidth(root_child0, 72);
1572   YGNodeStyleSetHeight(root_child0, 72);
1573   YGNodeInsertChild(root, root_child0, 0);
1574   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1575
1576   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1577   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1578   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetWidth(root));
1579   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetHeight(root));
1580
1581   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
1582   ASSERT_FLOAT_EQ(-10, YGNodeLayoutGetTop(root_child0));
1583   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetWidth(root_child0));
1584   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetHeight(root_child0));
1585
1586   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1587
1588   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1589   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1590   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetWidth(root));
1591   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetHeight(root));
1592
1593   ASSERT_FLOAT_EQ(-30, YGNodeLayoutGetLeft(root_child0));
1594   ASSERT_FLOAT_EQ(-10, YGNodeLayoutGetTop(root_child0));
1595   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetWidth(root_child0));
1596   ASSERT_FLOAT_EQ(72, YGNodeLayoutGetHeight(root_child0));
1597
1598   YGNodeFreeRecursive(root);
1599
1600   YGConfigFree(config);
1601 }
1602
1603 TEST(YogaTest, margin_auto_top_stretching_child) {
1604   const YGConfigRef config = YGConfigNew();
1605
1606   const YGNodeRef root = YGNodeNewWithConfig(config);
1607   YGNodeStyleSetAlignItems(root, YGAlignCenter);
1608   YGNodeStyleSetWidth(root, 200);
1609   YGNodeStyleSetHeight(root, 200);
1610
1611   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1612   YGNodeStyleSetFlexGrow(root_child0, 1);
1613   YGNodeStyleSetFlexShrink(root_child0, 1);
1614   YGNodeStyleSetFlexBasisPercent(root_child0, 0);
1615   YGNodeStyleSetMarginAuto(root_child0, YGEdgeTop);
1616   YGNodeInsertChild(root, root_child0, 0);
1617
1618   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
1619   YGNodeStyleSetWidth(root_child1, 50);
1620   YGNodeStyleSetHeight(root_child1, 50);
1621   YGNodeInsertChild(root, root_child1, 1);
1622   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1623
1624   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1625   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1626   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1627   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1628
1629   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetLeft(root_child0));
1630   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1631   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
1632   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetHeight(root_child0));
1633
1634   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
1635   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
1636   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1637   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1638
1639   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1640
1641   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1642   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1643   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1644   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1645
1646   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetLeft(root_child0));
1647   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1648   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
1649   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetHeight(root_child0));
1650
1651   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
1652   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
1653   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1654   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1655
1656   YGNodeFreeRecursive(root);
1657
1658   YGConfigFree(config);
1659 }
1660
1661 TEST(YogaTest, margin_auto_left_stretching_child) {
1662   const YGConfigRef config = YGConfigNew();
1663
1664   const YGNodeRef root = YGNodeNewWithConfig(config);
1665   YGNodeStyleSetAlignItems(root, YGAlignCenter);
1666   YGNodeStyleSetWidth(root, 200);
1667   YGNodeStyleSetHeight(root, 200);
1668
1669   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1670   YGNodeStyleSetFlexGrow(root_child0, 1);
1671   YGNodeStyleSetFlexShrink(root_child0, 1);
1672   YGNodeStyleSetFlexBasisPercent(root_child0, 0);
1673   YGNodeStyleSetMarginAuto(root_child0, YGEdgeLeft);
1674   YGNodeInsertChild(root, root_child0, 0);
1675
1676   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
1677   YGNodeStyleSetWidth(root_child1, 50);
1678   YGNodeStyleSetHeight(root_child1, 50);
1679   YGNodeInsertChild(root, root_child1, 1);
1680   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1681
1682   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1683   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1684   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1685   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1686
1687   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetLeft(root_child0));
1688   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1689   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
1690   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetHeight(root_child0));
1691
1692   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
1693   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
1694   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1695   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1696
1697   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1698
1699   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1700   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1701   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1702   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1703
1704   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetLeft(root_child0));
1705   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1706   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
1707   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetHeight(root_child0));
1708
1709   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child1));
1710   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetTop(root_child1));
1711   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child1));
1712   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child1));
1713
1714   YGNodeFreeRecursive(root);
1715
1716   YGConfigFree(config);
1717 }