automated-tests/src/dali-toolkit-third-party/yoga/YGPercentageTest.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/YGPercentageTest.html
   9
  10 #include <gtest/gtest.h>
  11 #include <yoga/Yoga.h>
  12
  13 TEST(YogaTest, percentage_width_height) {
  14   const YGConfigRef config = YGConfigNew();
  15
  16   const YGNodeRef root = YGNodeNewWithConfig(config);
  17   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
  18   YGNodeStyleSetWidth(root, 200);
  19   YGNodeStyleSetHeight(root, 200);
  20
  21   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
  22   YGNodeStyleSetWidthPercent(root_child0, 30);
  23   YGNodeStyleSetHeightPercent(root_child0, 30);
  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(200, YGNodeLayoutGetWidth(root));
  30   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
  31
  32   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
  33   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
  34   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetWidth(root_child0));
  35   ASSERT_FLOAT_EQ(60, 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(200, YGNodeLayoutGetWidth(root));
  42   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
  43
  44   ASSERT_FLOAT_EQ(140, YGNodeLayoutGetLeft(root_child0));
  45   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
  46   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetWidth(root_child0));
  47   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetHeight(root_child0));
  48
  49   YGNodeFreeRecursive(root);
  50
  51   YGConfigFree(config);
  52 }
  53
  54 TEST(YogaTest, percentage_position_left_top) {
  55   const YGConfigRef config = YGConfigNew();
  56
  57   const YGNodeRef root = YGNodeNewWithConfig(config);
  58   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
  59   YGNodeStyleSetWidth(root, 400);
  60   YGNodeStyleSetHeight(root, 400);
  61
  62   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
  63   YGNodeStyleSetPositionPercent(root_child0, YGEdgeLeft, 10);
  64   YGNodeStyleSetPositionPercent(root_child0, YGEdgeTop, 20);
  65   YGNodeStyleSetWidthPercent(root_child0, 45);
  66   YGNodeStyleSetHeightPercent(root_child0, 55);
  67   YGNodeInsertChild(root, root_child0, 0);
  68   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
  69
  70   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
  71   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
  72   ASSERT_FLOAT_EQ(400, YGNodeLayoutGetWidth(root));
  73   ASSERT_FLOAT_EQ(400, YGNodeLayoutGetHeight(root));
  74
  75   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetLeft(root_child0));
  76   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetTop(root_child0));
  77   ASSERT_FLOAT_EQ(180, YGNodeLayoutGetWidth(root_child0));
  78   ASSERT_FLOAT_EQ(220, YGNodeLayoutGetHeight(root_child0));
  79
  80   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
  81
  82   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
  83   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
  84   ASSERT_FLOAT_EQ(400, YGNodeLayoutGetWidth(root));
  85   ASSERT_FLOAT_EQ(400, YGNodeLayoutGetHeight(root));
  86
  87   ASSERT_FLOAT_EQ(260, YGNodeLayoutGetLeft(root_child0));
  88   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetTop(root_child0));
  89   ASSERT_FLOAT_EQ(180, YGNodeLayoutGetWidth(root_child0));
  90   ASSERT_FLOAT_EQ(220, YGNodeLayoutGetHeight(root_child0));
  91
  92   YGNodeFreeRecursive(root);
  93
  94   YGConfigFree(config);
  95 }
  96
  97 TEST(YogaTest, percentage_position_bottom_right) {
  98   const YGConfigRef config = YGConfigNew();
  99
 100   const YGNodeRef root = YGNodeNewWithConfig(config);
 101   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 102   YGNodeStyleSetWidth(root, 500);
 103   YGNodeStyleSetHeight(root, 500);
 104
 105   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 106   YGNodeStyleSetPositionPercent(root_child0, YGEdgeRight, 20);
 107   YGNodeStyleSetPositionPercent(root_child0, YGEdgeBottom, 10);
 108   YGNodeStyleSetWidthPercent(root_child0, 55);
 109   YGNodeStyleSetHeightPercent(root_child0, 15);
 110   YGNodeInsertChild(root, root_child0, 0);
 111   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 112
 113   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 114   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 115   ASSERT_FLOAT_EQ(500, YGNodeLayoutGetWidth(root));
 116   ASSERT_FLOAT_EQ(500, YGNodeLayoutGetHeight(root));
 117
 118   ASSERT_FLOAT_EQ(-100, YGNodeLayoutGetLeft(root_child0));
 119   ASSERT_FLOAT_EQ(-50, YGNodeLayoutGetTop(root_child0));
 120   ASSERT_FLOAT_EQ(275, YGNodeLayoutGetWidth(root_child0));
 121   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetHeight(root_child0));
 122
 123   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 124
 125   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 126   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 127   ASSERT_FLOAT_EQ(500, YGNodeLayoutGetWidth(root));
 128   ASSERT_FLOAT_EQ(500, YGNodeLayoutGetHeight(root));
 129
 130   ASSERT_FLOAT_EQ(125, YGNodeLayoutGetLeft(root_child0));
 131   ASSERT_FLOAT_EQ(-50, YGNodeLayoutGetTop(root_child0));
 132   ASSERT_FLOAT_EQ(275, YGNodeLayoutGetWidth(root_child0));
 133   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetHeight(root_child0));
 134
 135   YGNodeFreeRecursive(root);
 136
 137   YGConfigFree(config);
 138 }
 139
 140 TEST(YogaTest, percentage_flex_basis) {
 141   const YGConfigRef config = YGConfigNew();
 142
 143   const YGNodeRef root = YGNodeNewWithConfig(config);
 144   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 145   YGNodeStyleSetWidth(root, 200);
 146   YGNodeStyleSetHeight(root, 200);
 147
 148   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 149   YGNodeStyleSetFlexGrow(root_child0, 1);
 150   YGNodeStyleSetFlexBasisPercent(root_child0, 50);
 151   YGNodeInsertChild(root, root_child0, 0);
 152
 153   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 154   YGNodeStyleSetFlexGrow(root_child1, 1);
 155   YGNodeStyleSetFlexBasisPercent(root_child1, 25);
 156   YGNodeInsertChild(root, root_child1, 1);
 157   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 158
 159   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 160   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 161   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 162   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 163
 164   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 165   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 166   ASSERT_FLOAT_EQ(125, YGNodeLayoutGetWidth(root_child0));
 167   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child0));
 168
 169   ASSERT_FLOAT_EQ(125, YGNodeLayoutGetLeft(root_child1));
 170   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 171   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetWidth(root_child1));
 172   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child1));
 173
 174   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 175
 176   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 177   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 178   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 179   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 180
 181   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
 182   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 183   ASSERT_FLOAT_EQ(125, YGNodeLayoutGetWidth(root_child0));
 184   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child0));
 185
 186   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 187   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 188   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetWidth(root_child1));
 189   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child1));
 190
 191   YGNodeFreeRecursive(root);
 192
 193   YGConfigFree(config);
 194 }
 195
 196 TEST(YogaTest, percentage_flex_basis_cross) {
 197   const YGConfigRef config = YGConfigNew();
 198
 199   const YGNodeRef root = YGNodeNewWithConfig(config);
 200   YGNodeStyleSetWidth(root, 200);
 201   YGNodeStyleSetHeight(root, 200);
 202
 203   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 204   YGNodeStyleSetFlexGrow(root_child0, 1);
 205   YGNodeStyleSetFlexBasisPercent(root_child0, 50);
 206   YGNodeInsertChild(root, root_child0, 0);
 207
 208   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 209   YGNodeStyleSetFlexGrow(root_child1, 1);
 210   YGNodeStyleSetFlexBasisPercent(root_child1, 25);
 211   YGNodeInsertChild(root, root_child1, 1);
 212   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 213
 214   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 215   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 216   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 217   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 218
 219   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 220   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 221   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child0));
 222   ASSERT_FLOAT_EQ(125, YGNodeLayoutGetHeight(root_child0));
 223
 224   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 225   ASSERT_FLOAT_EQ(125, YGNodeLayoutGetTop(root_child1));
 226   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child1));
 227   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetHeight(root_child1));
 228
 229   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 230
 231   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 232   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 233   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 234   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 235
 236   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 237   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 238   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child0));
 239   ASSERT_FLOAT_EQ(125, YGNodeLayoutGetHeight(root_child0));
 240
 241   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 242   ASSERT_FLOAT_EQ(125, YGNodeLayoutGetTop(root_child1));
 243   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child1));
 244   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetHeight(root_child1));
 245
 246   YGNodeFreeRecursive(root);
 247
 248   YGConfigFree(config);
 249 }
 250
 251 TEST(YogaTest, percentage_flex_basis_cross_min_height) {
 252   const YGConfigRef config = YGConfigNew();
 253
 254   const YGNodeRef root = YGNodeNewWithConfig(config);
 255   YGNodeStyleSetWidth(root, 200);
 256   YGNodeStyleSetHeight(root, 200);
 257
 258   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 259   YGNodeStyleSetFlexGrow(root_child0, 1);
 260   YGNodeStyleSetMinHeightPercent(root_child0, 60);
 261   YGNodeInsertChild(root, root_child0, 0);
 262
 263   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 264   YGNodeStyleSetFlexGrow(root_child1, 2);
 265   YGNodeStyleSetMinHeightPercent(root_child1, 10);
 266   YGNodeInsertChild(root, root_child1, 1);
 267   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 268
 269   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 270   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 271   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 272   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 273
 274   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 275   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 276   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child0));
 277   ASSERT_FLOAT_EQ(140, YGNodeLayoutGetHeight(root_child0));
 278
 279   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 280   ASSERT_FLOAT_EQ(140, YGNodeLayoutGetTop(root_child1));
 281   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child1));
 282   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetHeight(root_child1));
 283
 284   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 285
 286   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 287   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 288   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 289   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 290
 291   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 292   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 293   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child0));
 294   ASSERT_FLOAT_EQ(140, YGNodeLayoutGetHeight(root_child0));
 295
 296   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 297   ASSERT_FLOAT_EQ(140, YGNodeLayoutGetTop(root_child1));
 298   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child1));
 299   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetHeight(root_child1));
 300
 301   YGNodeFreeRecursive(root);
 302
 303   YGConfigFree(config);
 304 }
 305
 306 TEST(YogaTest, percentage_flex_basis_main_max_height) {
 307   const YGConfigRef config = YGConfigNew();
 308
 309   const YGNodeRef root = YGNodeNewWithConfig(config);
 310   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 311   YGNodeStyleSetWidth(root, 200);
 312   YGNodeStyleSetHeight(root, 200);
 313
 314   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 315   YGNodeStyleSetFlexGrow(root_child0, 1);
 316   YGNodeStyleSetFlexBasisPercent(root_child0, 10);
 317   YGNodeStyleSetMaxHeightPercent(root_child0, 60);
 318   YGNodeInsertChild(root, root_child0, 0);
 319
 320   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 321   YGNodeStyleSetFlexGrow(root_child1, 4);
 322   YGNodeStyleSetFlexBasisPercent(root_child1, 10);
 323   YGNodeStyleSetMaxHeightPercent(root_child1, 20);
 324   YGNodeInsertChild(root, root_child1, 1);
 325   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 326
 327   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 328   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 329   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 330   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 331
 332   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 333   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 334   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetWidth(root_child0));
 335   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetHeight(root_child0));
 336
 337   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetLeft(root_child1));
 338   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 339   ASSERT_FLOAT_EQ(148, YGNodeLayoutGetWidth(root_child1));
 340   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetHeight(root_child1));
 341
 342   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 343
 344   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 345   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 346   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 347   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 348
 349   ASSERT_FLOAT_EQ(148, YGNodeLayoutGetLeft(root_child0));
 350   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 351   ASSERT_FLOAT_EQ(52, YGNodeLayoutGetWidth(root_child0));
 352   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetHeight(root_child0));
 353
 354   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 355   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 356   ASSERT_FLOAT_EQ(148, YGNodeLayoutGetWidth(root_child1));
 357   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetHeight(root_child1));
 358
 359   YGNodeFreeRecursive(root);
 360
 361   YGConfigFree(config);
 362 }
 363
 364 TEST(YogaTest, percentage_flex_basis_cross_max_height) {
 365   const YGConfigRef config = YGConfigNew();
 366
 367   const YGNodeRef root = YGNodeNewWithConfig(config);
 368   YGNodeStyleSetWidth(root, 200);
 369   YGNodeStyleSetHeight(root, 200);
 370
 371   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 372   YGNodeStyleSetFlexGrow(root_child0, 1);
 373   YGNodeStyleSetFlexBasisPercent(root_child0, 10);
 374   YGNodeStyleSetMaxHeightPercent(root_child0, 60);
 375   YGNodeInsertChild(root, root_child0, 0);
 376
 377   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 378   YGNodeStyleSetFlexGrow(root_child1, 4);
 379   YGNodeStyleSetFlexBasisPercent(root_child1, 10);
 380   YGNodeStyleSetMaxHeightPercent(root_child1, 20);
 381   YGNodeInsertChild(root, root_child1, 1);
 382   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 383
 384   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 385   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 386   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 387   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 388
 389   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 390   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 391   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child0));
 392   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetHeight(root_child0));
 393
 394   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 395   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetTop(root_child1));
 396   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child1));
 397   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetHeight(root_child1));
 398
 399   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 400
 401   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 402   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 403   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 404   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 405
 406   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 407   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 408   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child0));
 409   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetHeight(root_child0));
 410
 411   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 412   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetTop(root_child1));
 413   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child1));
 414   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetHeight(root_child1));
 415
 416   YGNodeFreeRecursive(root);
 417
 418   YGConfigFree(config);
 419 }
 420
 421 TEST(YogaTest, percentage_flex_basis_main_max_width) {
 422   const YGConfigRef config = YGConfigNew();
 423
 424   const YGNodeRef root = YGNodeNewWithConfig(config);
 425   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 426   YGNodeStyleSetWidth(root, 200);
 427   YGNodeStyleSetHeight(root, 200);
 428
 429   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 430   YGNodeStyleSetFlexGrow(root_child0, 1);
 431   YGNodeStyleSetFlexBasisPercent(root_child0, 15);
 432   YGNodeStyleSetMaxWidthPercent(root_child0, 60);
 433   YGNodeInsertChild(root, root_child0, 0);
 434
 435   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 436   YGNodeStyleSetFlexGrow(root_child1, 4);
 437   YGNodeStyleSetFlexBasisPercent(root_child1, 10);
 438   YGNodeStyleSetMaxWidthPercent(root_child1, 20);
 439   YGNodeInsertChild(root, root_child1, 1);
 440   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 441
 442   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 443   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 444   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 445   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 446
 447   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 448   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 449   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child0));
 450   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child0));
 451
 452   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetLeft(root_child1));
 453   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 454   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child1));
 455   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child1));
 456
 457   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 458
 459   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 460   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 461   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 462   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 463
 464   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetLeft(root_child0));
 465   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 466   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child0));
 467   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child0));
 468
 469   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetLeft(root_child1));
 470   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 471   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child1));
 472   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child1));
 473
 474   YGNodeFreeRecursive(root);
 475
 476   YGConfigFree(config);
 477 }
 478
 479 TEST(YogaTest, percentage_flex_basis_cross_max_width) {
 480   const YGConfigRef config = YGConfigNew();
 481
 482   const YGNodeRef root = YGNodeNewWithConfig(config);
 483   YGNodeStyleSetWidth(root, 200);
 484   YGNodeStyleSetHeight(root, 200);
 485
 486   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 487   YGNodeStyleSetFlexGrow(root_child0, 1);
 488   YGNodeStyleSetFlexBasisPercent(root_child0, 10);
 489   YGNodeStyleSetMaxWidthPercent(root_child0, 60);
 490   YGNodeInsertChild(root, root_child0, 0);
 491
 492   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 493   YGNodeStyleSetFlexGrow(root_child1, 4);
 494   YGNodeStyleSetFlexBasisPercent(root_child1, 15);
 495   YGNodeStyleSetMaxWidthPercent(root_child1, 20);
 496   YGNodeInsertChild(root, root_child1, 1);
 497   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 498
 499   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 500   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 501   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 502   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 503
 504   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 505   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 506   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child0));
 507   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 508
 509   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 510   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
 511   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child1));
 512   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetHeight(root_child1));
 513
 514   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 515
 516   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 517   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 518   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 519   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 520
 521   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetLeft(root_child0));
 522   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 523   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child0));
 524   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 525
 526   ASSERT_FLOAT_EQ(160, YGNodeLayoutGetLeft(root_child1));
 527   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
 528   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child1));
 529   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetHeight(root_child1));
 530
 531   YGNodeFreeRecursive(root);
 532
 533   YGConfigFree(config);
 534 }
 535
 536 TEST(YogaTest, percentage_flex_basis_main_min_width) {
 537   const YGConfigRef config = YGConfigNew();
 538
 539   const YGNodeRef root = YGNodeNewWithConfig(config);
 540   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 541   YGNodeStyleSetWidth(root, 200);
 542   YGNodeStyleSetHeight(root, 200);
 543
 544   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 545   YGNodeStyleSetFlexGrow(root_child0, 1);
 546   YGNodeStyleSetFlexBasisPercent(root_child0, 15);
 547   YGNodeStyleSetMinWidthPercent(root_child0, 60);
 548   YGNodeInsertChild(root, root_child0, 0);
 549
 550   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 551   YGNodeStyleSetFlexGrow(root_child1, 4);
 552   YGNodeStyleSetFlexBasisPercent(root_child1, 10);
 553   YGNodeStyleSetMinWidthPercent(root_child1, 20);
 554   YGNodeInsertChild(root, root_child1, 1);
 555   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 556
 557   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 558   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 559   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 560   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 561
 562   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 563   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 564   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child0));
 565   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child0));
 566
 567   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetLeft(root_child1));
 568   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 569   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetWidth(root_child1));
 570   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child1));
 571
 572   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 573
 574   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 575   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 576   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 577   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 578
 579   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetLeft(root_child0));
 580   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 581   ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child0));
 582   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child0));
 583
 584   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 585   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 586   ASSERT_FLOAT_EQ(80, YGNodeLayoutGetWidth(root_child1));
 587   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root_child1));
 588
 589   YGNodeFreeRecursive(root);
 590
 591   YGConfigFree(config);
 592 }
 593
 594 TEST(YogaTest, percentage_flex_basis_cross_min_width) {
 595   const YGConfigRef config = YGConfigNew();
 596
 597   const YGNodeRef root = YGNodeNewWithConfig(config);
 598   YGNodeStyleSetWidth(root, 200);
 599   YGNodeStyleSetHeight(root, 200);
 600
 601   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 602   YGNodeStyleSetFlexGrow(root_child0, 1);
 603   YGNodeStyleSetFlexBasisPercent(root_child0, 10);
 604   YGNodeStyleSetMinWidthPercent(root_child0, 60);
 605   YGNodeInsertChild(root, root_child0, 0);
 606
 607   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 608   YGNodeStyleSetFlexGrow(root_child1, 4);
 609   YGNodeStyleSetFlexBasisPercent(root_child1, 15);
 610   YGNodeStyleSetMinWidthPercent(root_child1, 20);
 611   YGNodeInsertChild(root, root_child1, 1);
 612   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 613
 614   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 615   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 616   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 617   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 618
 619   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 620   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 621   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child0));
 622   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 623
 624   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 625   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
 626   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child1));
 627   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetHeight(root_child1));
 628
 629   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 630
 631   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 632   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 633   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 634   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 635
 636   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 637   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 638   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child0));
 639   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
 640
 641   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 642   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetTop(root_child1));
 643   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child1));
 644   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetHeight(root_child1));
 645
 646   YGNodeFreeRecursive(root);
 647
 648   YGConfigFree(config);
 649 }
 650
 651 TEST(YogaTest, percentage_multiple_nested_with_padding_margin_and_percentage_values) {
 652   const YGConfigRef config = YGConfigNew();
 653
 654   const YGNodeRef root = YGNodeNewWithConfig(config);
 655   YGNodeStyleSetWidth(root, 200);
 656   YGNodeStyleSetHeight(root, 200);
 657
 658   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 659   YGNodeStyleSetFlexGrow(root_child0, 1);
 660   YGNodeStyleSetFlexBasisPercent(root_child0, 10);
 661   YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 5);
 662   YGNodeStyleSetMargin(root_child0, YGEdgeTop, 5);
 663   YGNodeStyleSetMargin(root_child0, YGEdgeRight, 5);
 664   YGNodeStyleSetMargin(root_child0, YGEdgeBottom, 5);
 665   YGNodeStyleSetPadding(root_child0, YGEdgeLeft, 3);
 666   YGNodeStyleSetPadding(root_child0, YGEdgeTop, 3);
 667   YGNodeStyleSetPadding(root_child0, YGEdgeRight, 3);
 668   YGNodeStyleSetPadding(root_child0, YGEdgeBottom, 3);
 669   YGNodeStyleSetMinWidthPercent(root_child0, 60);
 670   YGNodeInsertChild(root, root_child0, 0);
 671
 672   const YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
 673   YGNodeStyleSetMargin(root_child0_child0, YGEdgeLeft, 5);
 674   YGNodeStyleSetMargin(root_child0_child0, YGEdgeTop, 5);
 675   YGNodeStyleSetMargin(root_child0_child0, YGEdgeRight, 5);
 676   YGNodeStyleSetMargin(root_child0_child0, YGEdgeBottom, 5);
 677   YGNodeStyleSetPaddingPercent(root_child0_child0, YGEdgeLeft, 3);
 678   YGNodeStyleSetPaddingPercent(root_child0_child0, YGEdgeTop, 3);
 679   YGNodeStyleSetPaddingPercent(root_child0_child0, YGEdgeRight, 3);
 680   YGNodeStyleSetPaddingPercent(root_child0_child0, YGEdgeBottom, 3);
 681   YGNodeStyleSetWidthPercent(root_child0_child0, 50);
 682   YGNodeInsertChild(root_child0, root_child0_child0, 0);
 683
 684   const YGNodeRef root_child0_child0_child0 = YGNodeNewWithConfig(config);
 685   YGNodeStyleSetMarginPercent(root_child0_child0_child0, YGEdgeLeft, 5);
 686   YGNodeStyleSetMarginPercent(root_child0_child0_child0, YGEdgeTop, 5);
 687   YGNodeStyleSetMarginPercent(root_child0_child0_child0, YGEdgeRight, 5);
 688   YGNodeStyleSetMarginPercent(root_child0_child0_child0, YGEdgeBottom, 5);
 689   YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeLeft, 3);
 690   YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeTop, 3);
 691   YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeRight, 3);
 692   YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeBottom, 3);
 693   YGNodeStyleSetWidthPercent(root_child0_child0_child0, 45);
 694   YGNodeInsertChild(root_child0_child0, root_child0_child0_child0, 0);
 695
 696   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 697   YGNodeStyleSetFlexGrow(root_child1, 4);
 698   YGNodeStyleSetFlexBasisPercent(root_child1, 15);
 699   YGNodeStyleSetMinWidthPercent(root_child1, 20);
 700   YGNodeInsertChild(root, root_child1, 1);
 701   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 702
 703   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 704   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 705   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 706   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
 707
 708   ASSERT_FLOAT_EQ(5, YGNodeLayoutGetLeft(root_child0));
 709   ASSERT_FLOAT_EQ(5, YGNodeLayoutGetTop(root_child0));
 710   ASSERT_FLOAT_EQ(190, YGNodeLayoutGetWidth(root_child0));
 711   ASSERT_FLOAT_EQ(48, YGNodeLayoutGetHeight(root_child0));
 712
 713   ASSERT_FLOAT_EQ(8, YGNodeLayoutGetLeft(root_child0_child0));
 714   ASSERT_FLOAT_EQ(8, YGNodeLayoutGetTop(root_child0_child0));
 715   ASSERT_FLOAT_EQ(92, YGNodeLayoutGetWidth(root_child0_child0));
 716   ASSERT_FLOAT_EQ(25, YGNodeLayoutGetHeight(root_child0_child0));
 717
 718   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetLeft(root_child0_child0_child0));
 719   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0_child0_child0));
 720   ASSERT_FLOAT_EQ(36, YGNodeLayoutGetWidth(root_child0_child0_child0));
 721   ASSERT_FLOAT_EQ(6, YGNodeLayoutGetHeight(root_child0_child0_child0));
 722
 723   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 724   ASSERT_FLOAT_EQ(58, YGNodeLayoutGetTop(root_child1));
 725   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child1));
 726   ASSERT_FLOAT_EQ(142, YGNodeLayoutGetHeight(root_child1));
 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(5, YGNodeLayoutGetLeft(root_child0));
 736   ASSERT_FLOAT_EQ(5, YGNodeLayoutGetTop(root_child0));
 737   ASSERT_FLOAT_EQ(190, YGNodeLayoutGetWidth(root_child0));
 738   ASSERT_FLOAT_EQ(48, YGNodeLayoutGetHeight(root_child0));
 739
 740   ASSERT_FLOAT_EQ(90, YGNodeLayoutGetLeft(root_child0_child0));
 741   ASSERT_FLOAT_EQ(8, YGNodeLayoutGetTop(root_child0_child0));
 742   ASSERT_FLOAT_EQ(92, YGNodeLayoutGetWidth(root_child0_child0));
 743   ASSERT_FLOAT_EQ(25, YGNodeLayoutGetHeight(root_child0_child0));
 744
 745   ASSERT_FLOAT_EQ(46, YGNodeLayoutGetLeft(root_child0_child0_child0));
 746   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0_child0_child0));
 747   ASSERT_FLOAT_EQ(36, YGNodeLayoutGetWidth(root_child0_child0_child0));
 748   ASSERT_FLOAT_EQ(6, YGNodeLayoutGetHeight(root_child0_child0_child0));
 749
 750   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
 751   ASSERT_FLOAT_EQ(58, YGNodeLayoutGetTop(root_child1));
 752   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child1));
 753   ASSERT_FLOAT_EQ(142, YGNodeLayoutGetHeight(root_child1));
 754
 755   YGNodeFreeRecursive(root);
 756
 757   YGConfigFree(config);
 758 }
 759
 760 TEST(YogaTest, percentage_margin_should_calculate_based_only_on_width) {
 761   const YGConfigRef config = YGConfigNew();
 762
 763   const YGNodeRef root = YGNodeNewWithConfig(config);
 764   YGNodeStyleSetWidth(root, 200);
 765   YGNodeStyleSetHeight(root, 100);
 766
 767   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 768   YGNodeStyleSetFlexGrow(root_child0, 1);
 769   YGNodeStyleSetMarginPercent(root_child0, YGEdgeLeft, 10);
 770   YGNodeStyleSetMarginPercent(root_child0, YGEdgeTop, 10);
 771   YGNodeStyleSetMarginPercent(root_child0, YGEdgeRight, 10);
 772   YGNodeStyleSetMarginPercent(root_child0, YGEdgeBottom, 10);
 773   YGNodeInsertChild(root, root_child0, 0);
 774
 775   const YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
 776   YGNodeStyleSetWidth(root_child0_child0, 10);
 777   YGNodeStyleSetHeight(root_child0_child0, 10);
 778   YGNodeInsertChild(root_child0, root_child0_child0, 0);
 779   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 780
 781   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 782   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 783   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 784   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 785
 786   ASSERT_FLOAT_EQ(20, YGNodeLayoutGetLeft(root_child0));
 787   ASSERT_FLOAT_EQ(20, YGNodeLayoutGetTop(root_child0));
 788   ASSERT_FLOAT_EQ(160, YGNodeLayoutGetWidth(root_child0));
 789   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetHeight(root_child0));
 790
 791   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
 792   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
 793   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetWidth(root_child0_child0));
 794   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
 795
 796   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 797
 798   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 799   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 800   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 801   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 802
 803   ASSERT_FLOAT_EQ(20, YGNodeLayoutGetLeft(root_child0));
 804   ASSERT_FLOAT_EQ(20, YGNodeLayoutGetTop(root_child0));
 805   ASSERT_FLOAT_EQ(160, YGNodeLayoutGetWidth(root_child0));
 806   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetHeight(root_child0));
 807
 808   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0_child0));
 809   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
 810   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetWidth(root_child0_child0));
 811   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
 812
 813   YGNodeFreeRecursive(root);
 814
 815   YGConfigFree(config);
 816 }
 817
 818 TEST(YogaTest, percentage_padding_should_calculate_based_only_on_width) {
 819   const YGConfigRef config = YGConfigNew();
 820
 821   const YGNodeRef root = YGNodeNewWithConfig(config);
 822   YGNodeStyleSetWidth(root, 200);
 823   YGNodeStyleSetHeight(root, 100);
 824
 825   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 826   YGNodeStyleSetFlexGrow(root_child0, 1);
 827   YGNodeStyleSetPaddingPercent(root_child0, YGEdgeLeft, 10);
 828   YGNodeStyleSetPaddingPercent(root_child0, YGEdgeTop, 10);
 829   YGNodeStyleSetPaddingPercent(root_child0, YGEdgeRight, 10);
 830   YGNodeStyleSetPaddingPercent(root_child0, YGEdgeBottom, 10);
 831   YGNodeInsertChild(root, root_child0, 0);
 832
 833   const YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
 834   YGNodeStyleSetWidth(root_child0_child0, 10);
 835   YGNodeStyleSetHeight(root_child0_child0, 10);
 836   YGNodeInsertChild(root_child0, root_child0_child0, 0);
 837   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 838
 839   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 840   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 841   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 842   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 843
 844   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 845   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 846   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child0));
 847   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 848
 849   ASSERT_FLOAT_EQ(20, YGNodeLayoutGetLeft(root_child0_child0));
 850   ASSERT_FLOAT_EQ(20, YGNodeLayoutGetTop(root_child0_child0));
 851   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetWidth(root_child0_child0));
 852   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
 853
 854   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 855
 856   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 857   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 858   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 859   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 860
 861   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 862   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 863   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root_child0));
 864   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 865
 866   ASSERT_FLOAT_EQ(170, YGNodeLayoutGetLeft(root_child0_child0));
 867   ASSERT_FLOAT_EQ(20, YGNodeLayoutGetTop(root_child0_child0));
 868   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetWidth(root_child0_child0));
 869   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
 870
 871   YGNodeFreeRecursive(root);
 872
 873   YGConfigFree(config);
 874 }
 875
 876 TEST(YogaTest, percentage_absolute_position) {
 877   const YGConfigRef config = YGConfigNew();
 878
 879   const YGNodeRef root = YGNodeNewWithConfig(config);
 880   YGNodeStyleSetWidth(root, 200);
 881   YGNodeStyleSetHeight(root, 100);
 882
 883   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 884   YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute);
 885   YGNodeStyleSetPositionPercent(root_child0, YGEdgeLeft, 30);
 886   YGNodeStyleSetPositionPercent(root_child0, YGEdgeTop, 10);
 887   YGNodeStyleSetWidth(root_child0, 10);
 888   YGNodeStyleSetHeight(root_child0, 10);
 889   YGNodeInsertChild(root, root_child0, 0);
 890   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 891
 892   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 893   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 894   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 895   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 896
 897   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetLeft(root_child0));
 898   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0));
 899   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetWidth(root_child0));
 900   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0));
 901
 902   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 903
 904   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 905   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 906   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
 907   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 908
 909   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetLeft(root_child0));
 910   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0));
 911   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetWidth(root_child0));
 912   ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0));
 913
 914   YGNodeFreeRecursive(root);
 915
 916   YGConfigFree(config);
 917 }
 918
 919 TEST(YogaTest, percentage_width_height_undefined_parent_size) {
 920   const YGConfigRef config = YGConfigNew();
 921
 922   const YGNodeRef root = YGNodeNewWithConfig(config);
 923
 924   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 925   YGNodeStyleSetWidthPercent(root_child0, 50);
 926   YGNodeStyleSetHeightPercent(root_child0, 50);
 927   YGNodeInsertChild(root, root_child0, 0);
 928   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 929
 930   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 931   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 932   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root));
 933   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root));
 934
 935   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 936   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 937   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
 938   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
 939
 940   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
 941
 942   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 943   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 944   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root));
 945   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root));
 946
 947   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 948   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 949   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
 950   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
 951
 952   YGNodeFreeRecursive(root);
 953
 954   YGConfigFree(config);
 955 }
 956
 957 TEST(YogaTest, percent_within_flex_grow) {
 958   const YGConfigRef config = YGConfigNew();
 959
 960   const YGNodeRef root = YGNodeNewWithConfig(config);
 961   YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
 962   YGNodeStyleSetWidth(root, 350);
 963   YGNodeStyleSetHeight(root, 100);
 964
 965   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
 966   YGNodeStyleSetWidth(root_child0, 100);
 967   YGNodeInsertChild(root, root_child0, 0);
 968
 969   const YGNodeRef root_child1 = YGNodeNewWithConfig(config);
 970   YGNodeStyleSetFlexGrow(root_child1, 1);
 971   YGNodeInsertChild(root, root_child1, 1);
 972
 973   const YGNodeRef root_child1_child0 = YGNodeNewWithConfig(config);
 974   YGNodeStyleSetWidthPercent(root_child1_child0, 100);
 975   YGNodeInsertChild(root_child1, root_child1_child0, 0);
 976
 977   const YGNodeRef root_child2 = YGNodeNewWithConfig(config);
 978   YGNodeStyleSetWidth(root_child2, 100);
 979   YGNodeInsertChild(root, root_child2, 2);
 980   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
 981
 982   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
 983   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
 984   ASSERT_FLOAT_EQ(350, YGNodeLayoutGetWidth(root));
 985   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
 986
 987   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
 988   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
 989   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
 990   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
 991
 992   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetLeft(root_child1));
 993   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
 994   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child1));
 995   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
 996
 997   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1_child0));
 998   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1_child0));
 999   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child1_child0));
1000   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child1_child0));
1001
1002   ASSERT_FLOAT_EQ(250, YGNodeLayoutGetLeft(root_child2));
1003   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child2));
1004   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child2));
1005   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child2));
1006
1007   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1008
1009   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1010   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1011   ASSERT_FLOAT_EQ(350, YGNodeLayoutGetWidth(root));
1012   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
1013
1014   ASSERT_FLOAT_EQ(250, YGNodeLayoutGetLeft(root_child0));
1015   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1016   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
1017   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child0));
1018
1019   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetLeft(root_child1));
1020   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
1021   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child1));
1022   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
1023
1024   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1_child0));
1025   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1_child0));
1026   ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child1_child0));
1027   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child1_child0));
1028
1029   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child2));
1030   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child2));
1031   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child2));
1032   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child2));
1033
1034   YGNodeFreeRecursive(root);
1035
1036   YGConfigFree(config);
1037 }
1038
1039 TEST(YogaTest, percentage_container_in_wrapping_container) {
1040   const YGConfigRef config = YGConfigNew();
1041
1042   const YGNodeRef root = YGNodeNewWithConfig(config);
1043   YGNodeStyleSetJustifyContent(root, YGJustifyCenter);
1044   YGNodeStyleSetAlignItems(root, YGAlignCenter);
1045   YGNodeStyleSetWidth(root, 200);
1046   YGNodeStyleSetHeight(root, 200);
1047
1048   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1049   YGNodeInsertChild(root, root_child0, 0);
1050
1051   const YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
1052   YGNodeStyleSetFlexDirection(root_child0_child0, YGFlexDirectionRow);
1053   YGNodeStyleSetJustifyContent(root_child0_child0, YGJustifyCenter);
1054   YGNodeStyleSetWidthPercent(root_child0_child0, 100);
1055   YGNodeInsertChild(root_child0, root_child0_child0, 0);
1056
1057   const YGNodeRef root_child0_child0_child0 = YGNodeNewWithConfig(config);
1058   YGNodeStyleSetWidth(root_child0_child0_child0, 50);
1059   YGNodeStyleSetHeight(root_child0_child0_child0, 50);
1060   YGNodeInsertChild(root_child0_child0, root_child0_child0_child0, 0);
1061
1062   const YGNodeRef root_child0_child0_child1 = YGNodeNewWithConfig(config);
1063   YGNodeStyleSetWidth(root_child0_child0_child1, 50);
1064   YGNodeStyleSetHeight(root_child0_child0_child1, 50);
1065   YGNodeInsertChild(root_child0_child0, root_child0_child0_child1, 1);
1066   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1067
1068   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1069   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1070   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1071   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1072
1073   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0));
1074   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child0));
1075   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
1076   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1077
1078   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
1079   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
1080   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0_child0));
1081   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0_child0));
1082
1083   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0_child0));
1084   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child0));
1085   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0_child0));
1086   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0_child0_child0));
1087
1088   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child0_child1));
1089   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child1));
1090   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0_child1));
1091   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0_child0_child1));
1092
1093   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1094
1095   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1096   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1097   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetWidth(root));
1098   ASSERT_FLOAT_EQ(200, YGNodeLayoutGetHeight(root));
1099
1100   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0));
1101   ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child0));
1102   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0));
1103   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1104
1105   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
1106   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
1107   ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child0_child0));
1108   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0_child0));
1109
1110   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child0_child0));
1111   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child0));
1112   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0_child0));
1113   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0_child0_child0));
1114
1115   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0_child1));
1116   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child1));
1117   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0_child1));
1118   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0_child0_child1));
1119
1120   YGNodeFreeRecursive(root);
1121
1122   YGConfigFree(config);
1123 }
1124
1125 TEST(YogaTest, percent_absolute_position) {
1126   const YGConfigRef config = YGConfigNew();
1127
1128   const YGNodeRef root = YGNodeNewWithConfig(config);
1129   YGNodeStyleSetWidth(root, 60);
1130   YGNodeStyleSetHeight(root, 50);
1131
1132   const YGNodeRef root_child0 = YGNodeNewWithConfig(config);
1133   YGNodeStyleSetFlexDirection(root_child0, YGFlexDirectionRow);
1134   YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute);
1135   YGNodeStyleSetPositionPercent(root_child0, YGEdgeLeft, 50);
1136   YGNodeStyleSetWidthPercent(root_child0, 100);
1137   YGNodeStyleSetHeight(root_child0, 50);
1138   YGNodeInsertChild(root, root_child0, 0);
1139
1140   const YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
1141   YGNodeStyleSetWidthPercent(root_child0_child0, 100);
1142   YGNodeInsertChild(root_child0, root_child0_child0, 0);
1143
1144   const YGNodeRef root_child0_child1 = YGNodeNewWithConfig(config);
1145   YGNodeStyleSetWidthPercent(root_child0_child1, 100);
1146   YGNodeInsertChild(root_child0, root_child0_child1, 1);
1147   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
1148
1149   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1150   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1151   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetWidth(root));
1152   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root));
1153
1154   ASSERT_FLOAT_EQ(30, YGNodeLayoutGetLeft(root_child0));
1155   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1156   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetWidth(root_child0));
1157   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1158
1159   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
1160   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
1161   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetWidth(root_child0_child0));
1162   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0_child0));
1163
1164   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetLeft(root_child0_child1));
1165   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
1166   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetWidth(root_child0_child1));
1167   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0_child1));
1168
1169   YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
1170
1171   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
1172   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
1173   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetWidth(root));
1174   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root));
1175
1176   ASSERT_FLOAT_EQ(30, YGNodeLayoutGetLeft(root_child0));
1177   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
1178   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetWidth(root_child0));
1179   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
1180
1181   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
1182   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
1183   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetWidth(root_child0_child0));
1184   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0_child0));
1185
1186   ASSERT_FLOAT_EQ(-60, YGNodeLayoutGetLeft(root_child0_child1));
1187   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
1188   ASSERT_FLOAT_EQ(60, YGNodeLayoutGetWidth(root_child0_child1));
1189   ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0_child1));
1190
1191   YGNodeFreeRecursive(root);
1192
1193   YGConfigFree(config);
1194 }