tests/unit_tests/runtime/layout_stack_test.cpp - external/github.com/rive-app/rive-cpp - Git at Google

 #include "rive/artboard.hpp"
 #include "rive/layout/layout_component_style.hpp"
 #include "rive/layout/layout_node_provider.hpp"
 #include "rive/layout_component.hpp"
 #include "rive/math/aabb.hpp"
 #include "rive/nested_artboard_layout.hpp"
 #include "rive/shapes/shape.hpp"
 #include "rive_file_reader.hpp"
 #include "rive_testing.hpp"
 #include <catch.hpp>

 // Asset generated by rive_core/test/layout_stack_export_test.dart:
 // a 400x400 artboard with a 200x200 stack (layoutType=stack, bottomRight
 // alignment) containing a fill child and a fixed 40x40 box. Stack synthesizes a
 // 1x1 grid, so every child shares the single cell.
 TEST_CASE("stack overlaps children and aligns from a .riv file",
           "[layoutstack]")
 {
     auto file = ReadRiveFile("assets/layout/stack.riv");
     auto artboard = file->artboard();
     REQUIRE(artboard != nullptr);
     artboard->advance(0.0f);

     // The exporter strips names; identify layouts by structure.
     auto layouts = artboard->find<rive::LayoutComponent>();
     rive::LayoutComponent* stack = nullptr;
     rive::LayoutComponent* fill = nullptr;
     rive::LayoutComponent* box = nullptr;
     for (auto layout : layouts)
     {
         if (layout->is<rive::Artboard>() || layout->style() == nullptr)
         {
             continue;
         }
         if (layout->style()->isStack())
         {
             stack = layout;
         }
         else if (layout->style()->widthScaleType() ==
                  rive::LayoutScaleType::fill)
         {
             fill = layout;
         }
         else
         {
             box = layout;
         }
     }
     REQUIRE(stack != nullptr);
     REQUIRE(fill != nullptr);
     REQUIRE(box != nullptr);

     // The fill child occupies the entire cell (the whole 200x200 stack),
     // overlapping the box — proving both share the single stacked cell.
     REQUIRE(fill->layoutX() == 0.0f);
     REQUIRE(fill->layoutY() == 0.0f);
     REQUIRE(fill->layoutWidth() == 200.0f);
     REQUIRE(fill->layoutHeight() == 200.0f);

     // The fixed box keeps its size and sits at the bottom-right (alignment).
     REQUIRE(box->layoutWidth() == 40.0f);
     REQUIRE(box->layoutHeight() == 40.0f);
     REQUIRE(box->layoutX() == 160.0f);
     REQUIRE(box->layoutY() == 160.0f);
 }

 // Sweep the 9-way alignment and confirm the fixed box lands in the right spot.
 // Exercises start/center/end on both axes (grid uses End, not FlexEnd).
 TEST_CASE("stack alignment positions a fixed child", "[layoutstack]")
 {
     auto file = ReadRiveFile("assets/layout/stack.riv");
     auto artboard = file->artboard();
     REQUIRE(artboard != nullptr);
     artboard->advance(0.0f);

     auto layouts = artboard->find<rive::LayoutComponent>();
     rive::LayoutComponent* stack = nullptr;
     rive::LayoutComponent* box = nullptr;
     for (auto layout : layouts)
     {
         if (layout->is<rive::Artboard>() || layout->style() == nullptr)
         {
             continue;
         }
         if (layout->style()->isStack())
         {
             stack = layout;
         }
         else if (layout->style()->widthScaleType() !=
                  rive::LayoutScaleType::fill)
         {
             box = layout;
         }
     }
     REQUIRE(stack != nullptr);
     REQUIRE(box != nullptr);

     auto at = [&](rive::LayoutAlignmentType alignment, float x, float y) {
         stack->style()->layoutAlignmentType((uint32_t)alignment);
         artboard->advance(0.0f);
         REQUIRE(box->layoutX() == x);
         REQUIRE(box->layoutY() == y);
     };

     at(rive::LayoutAlignmentType::topLeft, 0.0f, 0.0f);
     at(rive::LayoutAlignmentType::topCenter, 80.0f, 0.0f);
     at(rive::LayoutAlignmentType::topRight, 160.0f, 0.0f);
     at(rive::LayoutAlignmentType::centerLeft, 0.0f, 80.0f);
     at(rive::LayoutAlignmentType::center, 80.0f, 80.0f);
     at(rive::LayoutAlignmentType::centerRight, 160.0f, 80.0f);
     at(rive::LayoutAlignmentType::bottomLeft, 0.0f, 160.0f);
     at(rive::LayoutAlignmentType::bottomCenter, 80.0f, 160.0f);
     at(rive::LayoutAlignmentType::bottomRight, 160.0f, 160.0f);
 }

 // display() folds visibility (displayValue) + algorithm (layoutTypeValue) into
 // the single YGDisplay the engine consumes: hidden wins, else flex vs grid.
 // Uses an attached style (from a loaded file) since the property setters fire
 // change handlers that walk to the owning layout.
 TEST_CASE("engine display folds visibility and layout type", "[layoutstack]")
 {
     auto file = ReadRiveFile("assets/layout/stack.riv");
     auto artboard = file->artboard();
     REQUIRE(artboard != nullptr);
     artboard->advance(0.0f);

     rive::LayoutComponentStyle* style = nullptr;
     for (auto layout : artboard->find<rive::LayoutComponent>())
     {
         if (!layout->is<rive::Artboard>() && layout->style() != nullptr &&
             layout->style()->isStack())
         {
             style = layout->style();
         }
     }
     REQUIRE(style != nullptr);

     style->displayValue(0); // visible
     style->layoutTypeValue(0 /* flex */);
     REQUIRE(style->display() == YGDisplayFlex);
     style->layoutTypeValue(1 /* grid */);
     REQUIRE(style->display() == YGDisplayGrid);
     style->layoutTypeValue(2 /* stack */);
     REQUIRE(style->display() == YGDisplayGrid);

     style->displayValue(1); // hidden — wins regardless of type
     style->layoutTypeValue(0);
     REQUIRE(style->display() == YGDisplayNone);
     style->layoutTypeValue(1);
     REQUIRE(style->display() == YGDisplayNone);
     style->layoutTypeValue(2);
     REQUIRE(style->display() == YGDisplayNone);
 }

 // Asset generated by tests/unit_tests/gen_layout_fixtures.py
 // (gen_nested_artboard_stack): a 200x200 stack holding two NestedArtboardLayout
 // instances of a 40x40 artboard, plus a MixedStack artboard where one nested
 // artboard shares the cell with a fill/fill participant.
 //
 // A hosted artboard is laid out through the inner ArtboardInstance's own yoga
 // node, and that instance has no parent() to walk for its container — the host
 // pushes the stack state in instead. Without it the instances keep yoga's
 // auto-placement and flow into implicit rows.
 TEST_CASE("nested artboards share the stacked cell", "[layoutstack]")
 {
     auto file = ReadRiveFile("assets/layout/nested_artboard_stack.riv");
     auto artboard = file->artboardNamed("TwoNested");
     REQUIRE(artboard != nullptr);
     artboard->advance(0.0f);

     auto nested = artboard->find<rive::NestedArtboardLayout>();
     REQUIRE(nested.size() == 2);
     for (auto* item : nested)
     {
         rive::AABB bounds = item->layoutBounds();
         // Both land in cell 1,1 — overlapped, not flowed into a second row.
         CHECK(bounds.left() == 0.0f);
         CHECK(bounds.top() == 0.0f);
         CHECK(bounds.width() == 40.0f);
         CHECK(bounds.height() == 40.0f);
     }
 }

 // The single-nested-artboard case only breaks once something else occupies the
 // cell: the participant is placed explicitly at 1,1, so an auto-placed nested
 // artboard is pushed into an implicit second row instead of overlapping it.
 TEST_CASE("a nested artboard overlaps a participant in a stack",
           "[layoutstack]")
 {
     auto file = ReadRiveFile("assets/layout/nested_artboard_stack.riv");
     auto artboard = file->artboardNamed("MixedStack");
     REQUIRE(artboard != nullptr);
     artboard->advance(0.0f);

     auto shapes = artboard->find<rive::Shape>();
     REQUIRE(shapes.size() == 1);
     auto* provider = rive::LayoutNodeProvider::from(shapes[0]);
     REQUIRE(provider != nullptr);
     rive::AABB fill = provider->layoutBounds();
     CHECK(fill.width() == 200.0f);
     CHECK(fill.height() == 200.0f);

     auto nested = artboard->find<rive::NestedArtboardLayout>();
     REQUIRE(nested.size() == 1);
     rive::AABB bounds = nested[0]->layoutBounds();
     CHECK(bounds.left() == 0.0f);
     CHECK(bounds.top() == 0.0f);
     CHECK(bounds.width() == 40.0f);
     CHECK(bounds.height() == 40.0f);
 }

 // Asset generated by tests/unit_tests/gen_layout_fixtures.py
 // (gen_nested_artboard_fill).
 //
 // A hosted artboard is sized by the host's override, not by the scale type
 // stored on its own style (fixed here). The item phase decides the inline
 // stretch, and a stack takes its justify-items from its alignment (start /
 // center / end — never stretch), so the override is the only thing that can
 // say stretch. Read the stored scale type there instead and a fill instance
 // keeps the source artboard's width in a stack while filling in a grid, whose
 // justify-items defaults to stretch and covers for it. The two must agree.
 TEST_CASE("a fill nested artboard fills a stack and a grid alike",
           "[layoutstack]")
 {
     auto boundsIn = [](const char* artboardName) {
         auto file = ReadRiveFile("assets/layout/nested_artboard_fill.riv");
         auto artboard = file->artboardNamed(artboardName);
         REQUIRE(artboard != nullptr);
         artboard->advance(0.0f);
         auto nested = artboard->find<rive::NestedArtboardLayout>();
         REQUIRE(nested.size() == 1);
         return nested[0]->layoutBounds();
     };

     // The instance is fill width / fixed 40 height in a 200x200 container.
     rive::AABB inGrid = boundsIn("NestedInGrid");
     rive::AABB inStack = boundsIn("NestedInStack");

     CHECK(inGrid.width() == 200.0f);
     CHECK(inGrid.height() == 40.0f);
     CHECK(inStack.width() == inGrid.width());
     CHECK(inStack.height() == inGrid.height());
     CHECK(inStack.left() == 0.0f);
     CHECK(inStack.top() == 0.0f);
 }

 // A stack synthesizes the same 1x1 grid, so it inherits the track's content
 // floor. Same reflowing child as grid_min_content's ReflowGrid: the cell has to
 // stay the stack's box and let the content wrap inside it.
 TEST_CASE("a stack cell floors at min-content too", "[layoutstack]")
 {
     auto file = ReadRiveFile("assets/layout/grid_min_content.riv");
     auto artboard = file->artboardNamed("ReflowStack");
     REQUIRE(artboard != nullptr);
     artboard->advance(0.0f);

     rive::LayoutComponent* container = nullptr;
     rive::LayoutComponent* child = nullptr;
     for (auto layout : artboard->find<rive::LayoutComponent>())
     {
         if (layout->is<rive::Artboard>())
         {
             continue;
         }
         if (layout->name() == "Container")
         {
             container = layout;
         }
         else if (layout->name() == "Child")
         {
             child = layout;
         }
     }
     REQUIRE(container != nullptr);
     REQUIRE(child != nullptr);

     CHECK(container->layoutWidth() == 400.0f);
     CHECK(child->layoutWidth() == 400.0f);
 }

 // Hug is decided by justify-self, and the downgrade that keeps a hug item off
 // stretch is guarded by the same effective-vs-stored scale type. Reading the
 // stored one (fixed, on HugItem's own style) left a hug instance stretched to
 // the whole column in a grid, while a stack hugged correctly -- the stack path
 // never consults it. The two must agree: 120, the content HugItem holds.
 TEST_CASE("a hug nested artboard hugs in a stack and a grid alike",
           "[layoutstack]")
 {
     auto boundsIn = [](const char* artboardName) {
         auto file = ReadRiveFile("assets/layout/nested_artboard_fill.riv");
         auto artboard = file->artboardNamed(artboardName);
         REQUIRE(artboard != nullptr);
         artboard->advance(0.0f);
         auto nested = artboard->find<rive::NestedArtboardLayout>();
         REQUIRE(nested.size() == 1);
         return nested[0]->layoutBounds();
     };

     // The instance is hug width / fixed 40 height in a 200x200 container.
     rive::AABB inStack = boundsIn("HugInStack");
     rive::AABB inGrid = boundsIn("HugInGrid");

     CHECK(inStack.width() == 120.0f);
     CHECK(inStack.height() == 40.0f);
     CHECK(inGrid.width() == inStack.width());
     CHECK(inGrid.height() == inStack.height());
 }
	#include "rive/artboard.hpp"
	#include "rive/layout/layout_component_style.hpp"
	#include "rive/layout/layout_node_provider.hpp"
	#include "rive/layout_component.hpp"
	#include "rive/math/aabb.hpp"
	#include "rive/nested_artboard_layout.hpp"
	#include "rive/shapes/shape.hpp"
	#include "rive_file_reader.hpp"
	#include "rive_testing.hpp"
	#include <catch.hpp>

	// Asset generated by rive_core/test/layout_stack_export_test.dart:
	// a 400x400 artboard with a 200x200 stack (layoutType=stack, bottomRight
	// alignment) containing a fill child and a fixed 40x40 box. Stack synthesizes a
	// 1x1 grid, so every child shares the single cell.
	TEST_CASE("stack overlaps children and aligns from a .riv file",
	"[layoutstack]")
	{
	auto file = ReadRiveFile("assets/layout/stack.riv");
	auto artboard = file->artboard();
	REQUIRE(artboard != nullptr);
	artboard->advance(0.0f);

	// The exporter strips names; identify layouts by structure.
	auto layouts = artboard->find<rive::LayoutComponent>();
	rive::LayoutComponent* stack = nullptr;
	rive::LayoutComponent* fill = nullptr;
	rive::LayoutComponent* box = nullptr;
	for (auto layout : layouts)
	{
	if (layout->is<rive::Artboard>() \|\| layout->style() == nullptr)
	{
	continue;
	}
	if (layout->style()->isStack())
	{
	stack = layout;
	}
	else if (layout->style()->widthScaleType() ==
	rive::LayoutScaleType::fill)
	{
	fill = layout;
	}
	else
	{
	box = layout;
	}
	}
	REQUIRE(stack != nullptr);
	REQUIRE(fill != nullptr);
	REQUIRE(box != nullptr);

	// The fill child occupies the entire cell (the whole 200x200 stack),
	// overlapping the box — proving both share the single stacked cell.
	REQUIRE(fill->layoutX() == 0.0f);
	REQUIRE(fill->layoutY() == 0.0f);
	REQUIRE(fill->layoutWidth() == 200.0f);
	REQUIRE(fill->layoutHeight() == 200.0f);

	// The fixed box keeps its size and sits at the bottom-right (alignment).
	REQUIRE(box->layoutWidth() == 40.0f);
	REQUIRE(box->layoutHeight() == 40.0f);
	REQUIRE(box->layoutX() == 160.0f);
	REQUIRE(box->layoutY() == 160.0f);
	}

	// Sweep the 9-way alignment and confirm the fixed box lands in the right spot.
	// Exercises start/center/end on both axes (grid uses End, not FlexEnd).
	TEST_CASE("stack alignment positions a fixed child", "[layoutstack]")
	{
	auto file = ReadRiveFile("assets/layout/stack.riv");
	auto artboard = file->artboard();
	REQUIRE(artboard != nullptr);
	artboard->advance(0.0f);

	auto layouts = artboard->find<rive::LayoutComponent>();
	rive::LayoutComponent* stack = nullptr;
	rive::LayoutComponent* box = nullptr;
	for (auto layout : layouts)
	{
	if (layout->is<rive::Artboard>() \|\| layout->style() == nullptr)
	{
	continue;
	}
	if (layout->style()->isStack())
	{
	stack = layout;
	}
	else if (layout->style()->widthScaleType() !=
	rive::LayoutScaleType::fill)
	{
	box = layout;
	}
	}
	REQUIRE(stack != nullptr);
	REQUIRE(box != nullptr);

	auto at = [&](rive::LayoutAlignmentType alignment, float x, float y) {
	stack->style()->layoutAlignmentType((uint32_t)alignment);
	artboard->advance(0.0f);
	REQUIRE(box->layoutX() == x);
	REQUIRE(box->layoutY() == y);
	};

	at(rive::LayoutAlignmentType::topLeft, 0.0f, 0.0f);
	at(rive::LayoutAlignmentType::topCenter, 80.0f, 0.0f);
	at(rive::LayoutAlignmentType::topRight, 160.0f, 0.0f);
	at(rive::LayoutAlignmentType::centerLeft, 0.0f, 80.0f);
	at(rive::LayoutAlignmentType::center, 80.0f, 80.0f);
	at(rive::LayoutAlignmentType::centerRight, 160.0f, 80.0f);
	at(rive::LayoutAlignmentType::bottomLeft, 0.0f, 160.0f);
	at(rive::LayoutAlignmentType::bottomCenter, 80.0f, 160.0f);
	at(rive::LayoutAlignmentType::bottomRight, 160.0f, 160.0f);
	}

	// display() folds visibility (displayValue) + algorithm (layoutTypeValue) into
	// the single YGDisplay the engine consumes: hidden wins, else flex vs grid.
	// Uses an attached style (from a loaded file) since the property setters fire
	// change handlers that walk to the owning layout.
	TEST_CASE("engine display folds visibility and layout type", "[layoutstack]")
	{
	auto file = ReadRiveFile("assets/layout/stack.riv");
	auto artboard = file->artboard();
	REQUIRE(artboard != nullptr);
	artboard->advance(0.0f);

	rive::LayoutComponentStyle* style = nullptr;
	for (auto layout : artboard->find<rive::LayoutComponent>())
	{
	if (!layout->is<rive::Artboard>() && layout->style() != nullptr &&
	layout->style()->isStack())
	{
	style = layout->style();
	}
	}
	REQUIRE(style != nullptr);

	style->displayValue(0); // visible
	style->layoutTypeValue(0 /* flex */);
	REQUIRE(style->display() == YGDisplayFlex);
	style->layoutTypeValue(1 /* grid */);
	REQUIRE(style->display() == YGDisplayGrid);
	style->layoutTypeValue(2 /* stack */);
	REQUIRE(style->display() == YGDisplayGrid);

	style->displayValue(1); // hidden — wins regardless of type
	style->layoutTypeValue(0);
	REQUIRE(style->display() == YGDisplayNone);
	style->layoutTypeValue(1);
	REQUIRE(style->display() == YGDisplayNone);
	style->layoutTypeValue(2);
	REQUIRE(style->display() == YGDisplayNone);
	}

	// Asset generated by tests/unit_tests/gen_layout_fixtures.py
	// (gen_nested_artboard_stack): a 200x200 stack holding two NestedArtboardLayout
	// instances of a 40x40 artboard, plus a MixedStack artboard where one nested
	// artboard shares the cell with a fill/fill participant.
	//
	// A hosted artboard is laid out through the inner ArtboardInstance's own yoga
	// node, and that instance has no parent() to walk for its container — the host
	// pushes the stack state in instead. Without it the instances keep yoga's
	// auto-placement and flow into implicit rows.
	TEST_CASE("nested artboards share the stacked cell", "[layoutstack]")
	{
	auto file = ReadRiveFile("assets/layout/nested_artboard_stack.riv");
	auto artboard = file->artboardNamed("TwoNested");
	REQUIRE(artboard != nullptr);
	artboard->advance(0.0f);

	auto nested = artboard->find<rive::NestedArtboardLayout>();
	REQUIRE(nested.size() == 2);
	for (auto* item : nested)
	{
	rive::AABB bounds = item->layoutBounds();
	// Both land in cell 1,1 — overlapped, not flowed into a second row.
	CHECK(bounds.left() == 0.0f);
	CHECK(bounds.top() == 0.0f);
	CHECK(bounds.width() == 40.0f);
	CHECK(bounds.height() == 40.0f);
	}
	}

	// The single-nested-artboard case only breaks once something else occupies the
	// cell: the participant is placed explicitly at 1,1, so an auto-placed nested
	// artboard is pushed into an implicit second row instead of overlapping it.
	TEST_CASE("a nested artboard overlaps a participant in a stack",
	"[layoutstack]")
	{
	auto file = ReadRiveFile("assets/layout/nested_artboard_stack.riv");
	auto artboard = file->artboardNamed("MixedStack");
	REQUIRE(artboard != nullptr);
	artboard->advance(0.0f);

	auto shapes = artboard->find<rive::Shape>();
	REQUIRE(shapes.size() == 1);
	auto* provider = rive::LayoutNodeProvider::from(shapes[0]);
	REQUIRE(provider != nullptr);
	rive::AABB fill = provider->layoutBounds();
	CHECK(fill.width() == 200.0f);
	CHECK(fill.height() == 200.0f);

	auto nested = artboard->find<rive::NestedArtboardLayout>();
	REQUIRE(nested.size() == 1);
	rive::AABB bounds = nested[0]->layoutBounds();
	CHECK(bounds.left() == 0.0f);
	CHECK(bounds.top() == 0.0f);
	CHECK(bounds.width() == 40.0f);
	CHECK(bounds.height() == 40.0f);
	}

	// Asset generated by tests/unit_tests/gen_layout_fixtures.py
	// (gen_nested_artboard_fill).
	//
	// A hosted artboard is sized by the host's override, not by the scale type
	// stored on its own style (fixed here). The item phase decides the inline
	// stretch, and a stack takes its justify-items from its alignment (start /
	// center / end — never stretch), so the override is the only thing that can
	// say stretch. Read the stored scale type there instead and a fill instance
	// keeps the source artboard's width in a stack while filling in a grid, whose
	// justify-items defaults to stretch and covers for it. The two must agree.
	TEST_CASE("a fill nested artboard fills a stack and a grid alike",
	"[layoutstack]")
	{
	auto boundsIn = [](const char* artboardName) {
	auto file = ReadRiveFile("assets/layout/nested_artboard_fill.riv");
	auto artboard = file->artboardNamed(artboardName);
	REQUIRE(artboard != nullptr);
	artboard->advance(0.0f);
	auto nested = artboard->find<rive::NestedArtboardLayout>();
	REQUIRE(nested.size() == 1);
	return nested[0]->layoutBounds();
	};

	// The instance is fill width / fixed 40 height in a 200x200 container.
	rive::AABB inGrid = boundsIn("NestedInGrid");
	rive::AABB inStack = boundsIn("NestedInStack");

	CHECK(inGrid.width() == 200.0f);
	CHECK(inGrid.height() == 40.0f);
	CHECK(inStack.width() == inGrid.width());
	CHECK(inStack.height() == inGrid.height());
	CHECK(inStack.left() == 0.0f);
	CHECK(inStack.top() == 0.0f);
	}

	// A stack synthesizes the same 1x1 grid, so it inherits the track's content
	// floor. Same reflowing child as grid_min_content's ReflowGrid: the cell has to
	// stay the stack's box and let the content wrap inside it.
	TEST_CASE("a stack cell floors at min-content too", "[layoutstack]")
	{
	auto file = ReadRiveFile("assets/layout/grid_min_content.riv");
	auto artboard = file->artboardNamed("ReflowStack");
	REQUIRE(artboard != nullptr);
	artboard->advance(0.0f);

	rive::LayoutComponent* container = nullptr;
	rive::LayoutComponent* child = nullptr;
	for (auto layout : artboard->find<rive::LayoutComponent>())
	{
	if (layout->is<rive::Artboard>())
	{
	continue;
	}
	if (layout->name() == "Container")
	{
	container = layout;
	}
	else if (layout->name() == "Child")
	{
	child = layout;
	}
	}
	REQUIRE(container != nullptr);
	REQUIRE(child != nullptr);

	CHECK(container->layoutWidth() == 400.0f);
	CHECK(child->layoutWidth() == 400.0f);
	}

	// Hug is decided by justify-self, and the downgrade that keeps a hug item off
	// stretch is guarded by the same effective-vs-stored scale type. Reading the
	// stored one (fixed, on HugItem's own style) left a hug instance stretched to
	// the whole column in a grid, while a stack hugged correctly -- the stack path
	// never consults it. The two must agree: 120, the content HugItem holds.
	TEST_CASE("a hug nested artboard hugs in a stack and a grid alike",
	"[layoutstack]")
	{
	auto boundsIn = [](const char* artboardName) {
	auto file = ReadRiveFile("assets/layout/nested_artboard_fill.riv");
	auto artboard = file->artboardNamed(artboardName);
	REQUIRE(artboard != nullptr);
	artboard->advance(0.0f);
	auto nested = artboard->find<rive::NestedArtboardLayout>();
	REQUIRE(nested.size() == 1);
	return nested[0]->layoutBounds();
	};

	// The instance is hug width / fixed 40 height in a 200x200 container.
	rive::AABB inStack = boundsIn("HugInStack");
	rive::AABB inGrid = boundsIn("HugInGrid");

	CHECK(inStack.width() == 120.0f);
	CHECK(inStack.height() == 40.0f);
	CHECK(inGrid.width() == inStack.width());
	CHECK(inGrid.height() == inStack.height());
	}