/**************************************************************************/
/* test_flow_container.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "tests/test_macros.h"
TEST_FORCE_LINK(test_flow_container)
#include "scene/gui/control.h"
#include "scene/gui/flow_container.h"
#include "scene/main/scene_tree.h"
#include "scene/main/window.h"
namespace TestFlowContainer {
TEST_CASE("[SceneTree][FlowContainer] HFlowContainer") {
HFlowContainer *hflow_container = memnew(HFlowContainer);
Window *root = SceneTree::get_singleton()->get_root();
root->add_child(hflow_container);
hflow_container->add_theme_constant_override("h_separation", 0);
hflow_container->add_theme_constant_override("v_separation", 0);
hflow_container->set_size(Size2(100, 100));
SceneTree::get_singleton()->process(0);
SUBCASE("Default behavior") {
Control *child_control_1 = memnew(Control);
Control *child_control_2 = memnew(Control);
Control *child_control_3 = memnew(Control);
child_control_1->set_custom_minimum_size(Size2(20, 10));
child_control_2->set_custom_minimum_size(Size2(20, 10));
child_control_3->set_custom_minimum_size(Size2(20, 10));
hflow_container->add_child(child_control_1);
hflow_container->add_child(child_control_2);
hflow_container->add_child(child_control_3);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
hflow_container->get_alignment() == FlowContainer::ALIGNMENT_BEGIN,
"HFlowContainer alignment is set to ALIGNMENT_BEGIN by default.");
CHECK_MESSAGE(
hflow_container->get_last_wrap_alignment() == FlowContainer::LAST_WRAP_ALIGNMENT_INHERIT,
"HFlowContainer last wrap alignment is set to LAST_WRAP_ALIGNMENT_INHERIT by default.");
CHECK_MESSAGE(
!hflow_container->is_vertical(),
"HFlowContainer is horizontal.");
CHECK_MESSAGE(
!hflow_container->is_reverse_fill(),
"HFlowContainer reverse fill is disabled by default.");
CHECK_MESSAGE(
hflow_container->get_line_count() == 1,
"HFlowContainer keeps all children in one line when there is enough horizontal space.");
CHECK_MESSAGE(
hflow_container->get_line_max_child_count() == 3,
"HFlowContainer reports the child count of the first line.");
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(0, 0)),
"First child control is positioned at the beginning of the line.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(20, 0)),
"Second child control is placed after the first child control.");
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(40, 0)),
"Third child control is placed after the second child control.");
memdelete(child_control_3);
memdelete(child_control_2);
memdelete(child_control_1);
}
SUBCASE("Wrapping and last wrap alignment") {
Control *child_control_1 = memnew(Control);
Control *child_control_2 = memnew(Control);
Control *child_control_3 = memnew(Control);
child_control_1->set_custom_minimum_size(Size2(20, 10));
child_control_2->set_custom_minimum_size(Size2(20, 10));
child_control_3->set_custom_minimum_size(Size2(20, 10));
hflow_container->set_size(Size2(50, 100));
hflow_container->add_child(child_control_1);
hflow_container->add_child(child_control_2);
hflow_container->add_child(child_control_3);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
hflow_container->get_line_count() == 2,
"HFlowContainer wraps children to a second line when they no longer fit.");
CHECK_MESSAGE(
hflow_container->get_line_max_child_count() == 2,
"HFlowContainer reports the first line child count as the line max child count.");
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(0, 0)),
"First child control starts at the first line origin.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(20, 0)),
"Second child control remains on the first line.");
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(0, 10)),
"Third child control wraps to the second line.");
hflow_container->set_last_wrap_alignment(FlowContainer::LAST_WRAP_ALIGNMENT_CENTER);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(10, 10)),
"Last wrapped line is centered relative to the previous line when LAST_WRAP_ALIGNMENT_CENTER is used.");
hflow_container->set_last_wrap_alignment(FlowContainer::LAST_WRAP_ALIGNMENT_END);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(20, 10)),
"Last wrapped line is aligned to the end relative to the previous line when LAST_WRAP_ALIGNMENT_END is used.");
memdelete(child_control_3);
memdelete(child_control_2);
memdelete(child_control_1);
}
SUBCASE("Alignment and RTL") {
Control *child_control_1 = memnew(Control);
Control *child_control_2 = memnew(Control);
child_control_1->set_custom_minimum_size(Size2(20, 10));
child_control_2->set_custom_minimum_size(Size2(20, 10));
hflow_container->set_size(Size2(100, 100));
hflow_container->add_child(child_control_1);
hflow_container->add_child(child_control_2);
SceneTree::get_singleton()->process(0);
hflow_container->set_alignment(FlowContainer::ALIGNMENT_CENTER);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(30, 0)),
"First child control is centered when ALIGNMENT_CENTER is used.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(50, 0)),
"Second child control follows centered alignment when ALIGNMENT_CENTER is used.");
hflow_container->set_alignment(FlowContainer::ALIGNMENT_END);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(60, 0)),
"First child control is aligned to the end when ALIGNMENT_END is used.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(80, 0)),
"Second child control is aligned to the end when ALIGNMENT_END is used.");
hflow_container->set_alignment(FlowContainer::ALIGNMENT_BEGIN);
hflow_container->set_layout_direction(Control::LAYOUT_DIRECTION_RTL);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(80, 0)),
"First child control starts at the right edge in RTL mode with ALIGNMENT_BEGIN.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(60, 0)),
"Second child control follows right-to-left ordering in RTL mode with ALIGNMENT_BEGIN.");
memdelete(child_control_2);
memdelete(child_control_1);
}
SUBCASE("Expanding children and stretch ratio") {
Control *child_control_1 = memnew(Control);
Control *child_control_2 = memnew(Control);
child_control_1->set_custom_minimum_size(Size2(20, 10));
child_control_2->set_custom_minimum_size(Size2(20, 10));
child_control_1->set_h_size_flags(Control::SIZE_EXPAND_FILL);
child_control_2->set_h_size_flags(Control::SIZE_EXPAND_FILL);
hflow_container->set_size(Size2(100, 100));
hflow_container->add_child(child_control_1);
hflow_container->add_child(child_control_2);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_size().is_equal_approx(Size2(50, 10)),
"First child control expands to half of the available width when both children have equal stretch ratio.");
CHECK_MESSAGE(
child_control_2->get_size().is_equal_approx(Size2(50, 10)),
"Second child control expands to half of the available width when both children have equal stretch ratio.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(50, 0)),
"Second child control is placed immediately after the first expanded child control.");
child_control_2->set_stretch_ratio(3.0f);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_size().is_equal_approx(Size2(35, 10)),
"First child control receives less width when its stretch ratio is lower.");
CHECK_MESSAGE(
child_control_2->get_size().is_equal_approx(Size2(65, 10)),
"Second child control receives more width when its stretch ratio is higher.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(35, 0)),
"Second child control starts after the first child control's stretched width.");
memdelete(child_control_2);
memdelete(child_control_1);
}
SUBCASE("Reverse fill") {
Control *child_control_1 = memnew(Control);
Control *child_control_2 = memnew(Control);
Control *child_control_3 = memnew(Control);
child_control_1->set_custom_minimum_size(Size2(20, 10));
child_control_2->set_custom_minimum_size(Size2(20, 10));
child_control_3->set_custom_minimum_size(Size2(20, 10));
hflow_container->set_size(Size2(50, 100));
hflow_container->add_child(child_control_1);
hflow_container->add_child(child_control_2);
hflow_container->add_child(child_control_3);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(0, 0)),
"First child control starts at the top row by default.");
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(0, 10)),
"Third child control wraps to the next row by default.");
hflow_container->set_reverse_fill(true);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(0, 90)),
"First child control moves to the bottom row when reverse fill is enabled.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(20, 90)),
"Second child control remains in the same row as the first child control when reverse fill is enabled.");
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(0, 80)),
"Wrapped row order is inverted from bottom to top when reverse fill is enabled.");
hflow_container->set_layout_direction(Control::LAYOUT_DIRECTION_RTL);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(30, 90)),
"RTL mirrors horizontal placement while reverse fill keeps rows bottom to top.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(10, 90)),
"Second child control follows mirrored RTL order while reverse fill remains enabled.");
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(30, 80)),
"Wrapped child control is mirrored in RTL while keeping reverse-filled row order.");
memdelete(child_control_3);
memdelete(child_control_2);
memdelete(child_control_1);
}
memdelete(hflow_container);
}
TEST_CASE("[SceneTree][FlowContainer] VFlowContainer") {
VFlowContainer *vflow_container = memnew(VFlowContainer);
Window *root = SceneTree::get_singleton()->get_root();
root->add_child(vflow_container);
vflow_container->add_theme_constant_override("h_separation", 0);
vflow_container->add_theme_constant_override("v_separation", 0);
vflow_container->set_size(Size2(100, 100));
SceneTree::get_singleton()->process(0);
SUBCASE("Default behavior") {
Control *child_control_1 = memnew(Control);
Control *child_control_2 = memnew(Control);
Control *child_control_3 = memnew(Control);
child_control_1->set_custom_minimum_size(Size2(20, 10));
child_control_2->set_custom_minimum_size(Size2(20, 10));
child_control_3->set_custom_minimum_size(Size2(20, 10));
vflow_container->add_child(child_control_1);
vflow_container->add_child(child_control_2);
vflow_container->add_child(child_control_3);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
vflow_container->get_alignment() == FlowContainer::ALIGNMENT_BEGIN,
"VFlowContainer alignment is set to ALIGNMENT_BEGIN by default.");
CHECK_MESSAGE(
vflow_container->get_last_wrap_alignment() == FlowContainer::LAST_WRAP_ALIGNMENT_INHERIT,
"VFlowContainer last wrap alignment is set to LAST_WRAP_ALIGNMENT_INHERIT by default.");
CHECK_MESSAGE(
vflow_container->is_vertical(),
"VFlowContainer is vertical.");
CHECK_MESSAGE(
!vflow_container->is_reverse_fill(),
"VFlowContainer reverse fill is disabled by default.");
CHECK_MESSAGE(
vflow_container->get_line_count() == 1,
"VFlowContainer keeps all children in one column when there is enough vertical space.");
CHECK_MESSAGE(
vflow_container->get_line_max_child_count() == 3,
"VFlowContainer reports the child count of the first column.");
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(0, 0)),
"First child control is positioned at the top of the first column.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(0, 10)),
"Second child control is placed below the first child control.");
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(0, 20)),
"Third child control is placed below the second child control.");
memdelete(child_control_3);
memdelete(child_control_2);
memdelete(child_control_1);
}
SUBCASE("Wrapping and last wrap alignment") {
Control *child_control_1 = memnew(Control);
Control *child_control_2 = memnew(Control);
Control *child_control_3 = memnew(Control);
child_control_1->set_custom_minimum_size(Size2(20, 20));
child_control_2->set_custom_minimum_size(Size2(20, 20));
child_control_3->set_custom_minimum_size(Size2(20, 20));
vflow_container->set_size(Size2(100, 50));
vflow_container->add_child(child_control_1);
vflow_container->add_child(child_control_2);
vflow_container->add_child(child_control_3);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
vflow_container->get_line_count() == 2,
"VFlowContainer wraps children to a second column when they no longer fit vertically.");
CHECK_MESSAGE(
vflow_container->get_line_max_child_count() == 2,
"VFlowContainer reports the first column child count as the line max child count.");
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(0, 0)),
"First child control starts at the first column origin.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(0, 20)),
"Second child control remains in the first column.");
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(20, 0)),
"Third child control wraps to the second column.");
vflow_container->set_last_wrap_alignment(FlowContainer::LAST_WRAP_ALIGNMENT_CENTER);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(20, 10)),
"Last wrapped column is centered relative to the previous column when LAST_WRAP_ALIGNMENT_CENTER is used.");
vflow_container->set_last_wrap_alignment(FlowContainer::LAST_WRAP_ALIGNMENT_END);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(20, 20)),
"Last wrapped column is aligned to the end relative to the previous column when LAST_WRAP_ALIGNMENT_END is used.");
memdelete(child_control_3);
memdelete(child_control_2);
memdelete(child_control_1);
}
SUBCASE("Alignment and RTL") {
Control *child_control_1 = memnew(Control);
Control *child_control_2 = memnew(Control);
child_control_1->set_custom_minimum_size(Size2(20, 20));
child_control_2->set_custom_minimum_size(Size2(20, 20));
vflow_container->set_size(Size2(100, 100));
vflow_container->add_child(child_control_1);
vflow_container->add_child(child_control_2);
SceneTree::get_singleton()->process(0);
vflow_container->set_alignment(FlowContainer::ALIGNMENT_CENTER);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(0, 30)),
"First child control is vertically centered when ALIGNMENT_CENTER is used.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(0, 50)),
"Second child control follows centered vertical alignment when ALIGNMENT_CENTER is used.");
vflow_container->set_alignment(FlowContainer::ALIGNMENT_END);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(0, 60)),
"First child control is aligned to the bottom when ALIGNMENT_END is used.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(0, 80)),
"Second child control is aligned to the bottom when ALIGNMENT_END is used.");
vflow_container->set_alignment(FlowContainer::ALIGNMENT_BEGIN);
vflow_container->set_layout_direction(Control::LAYOUT_DIRECTION_RTL);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(80, 0)),
"First child control moves to the right edge in RTL mode with vertical flow.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(80, 20)),
"Second child control follows RTL horizontal mirroring in vertical flow.");
memdelete(child_control_2);
memdelete(child_control_1);
}
SUBCASE("Expanding children and stretch ratio") {
Control *child_control_1 = memnew(Control);
Control *child_control_2 = memnew(Control);
child_control_1->set_custom_minimum_size(Size2(20, 20));
child_control_2->set_custom_minimum_size(Size2(20, 20));
child_control_1->set_v_size_flags(Control::SIZE_EXPAND_FILL);
child_control_2->set_v_size_flags(Control::SIZE_EXPAND_FILL);
vflow_container->set_size(Size2(100, 100));
vflow_container->add_child(child_control_1);
vflow_container->add_child(child_control_2);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_size().is_equal_approx(Size2(20, 50)),
"First child control expands to half of the available height when both children have equal stretch ratio.");
CHECK_MESSAGE(
child_control_2->get_size().is_equal_approx(Size2(20, 50)),
"Second child control expands to half of the available height when both children have equal stretch ratio.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(0, 50)),
"Second child control is placed immediately after the first expanded child control.");
child_control_2->set_stretch_ratio(3.0f);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_size().is_equal_approx(Size2(20, 35)),
"First child control receives less height when its stretch ratio is lower.");
CHECK_MESSAGE(
child_control_2->get_size().is_equal_approx(Size2(20, 65)),
"Second child control receives more height when its stretch ratio is higher.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(0, 35)),
"Second child control starts after the first child control's stretched height.");
memdelete(child_control_2);
memdelete(child_control_1);
}
SUBCASE("Reverse fill") {
Control *child_control_1 = memnew(Control);
Control *child_control_2 = memnew(Control);
Control *child_control_3 = memnew(Control);
child_control_1->set_custom_minimum_size(Size2(20, 20));
child_control_2->set_custom_minimum_size(Size2(20, 20));
child_control_3->set_custom_minimum_size(Size2(20, 20));
vflow_container->set_size(Size2(100, 30));
vflow_container->add_child(child_control_1);
vflow_container->add_child(child_control_2);
vflow_container->add_child(child_control_3);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(0, 0)),
"First child control starts in the first column by default.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(20, 0)),
"Second child control starts in the second column by default.");
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(40, 0)),
"Third child control starts in the third column by default.");
vflow_container->set_reverse_fill(true);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(80, 0)),
"First child control starts from the right when reverse fill is enabled in vertical mode.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(60, 0)),
"Second child control follows right-to-left column filling when reverse fill is enabled.");
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(40, 0)),
"Third child control continues right-to-left column filling when reverse fill is enabled.");
vflow_container->set_layout_direction(Control::LAYOUT_DIRECTION_RTL);
SceneTree::get_singleton()->process(0);
CHECK_MESSAGE(
child_control_1->get_position().is_equal_approx(Point2(0, 0)),
"Vertical flow with RTL and reverse fill fills columns from left to right.");
CHECK_MESSAGE(
child_control_2->get_position().is_equal_approx(Point2(20, 0)),
"Second child control follows left-to-right order in vertical mode with RTL and reverse fill.");
CHECK_MESSAGE(
child_control_3->get_position().is_equal_approx(Point2(40, 0)),
"Third child control follows left-to-right order in vertical mode with RTL and reverse fill.");
memdelete(child_control_3);
memdelete(child_control_2);
memdelete(child_control_1);
}
memdelete(vflow_container);
}
} // namespace TestFlowContainer