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