509 lines
20 KiB
C++
509 lines
20 KiB
C++
/**************************************************************************/
|
|
/* test_scroll_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_scroll_container)
|
|
|
|
#include "scene/gui/control.h"
|
|
#include "scene/gui/scroll_container.h"
|
|
#include "scene/main/scene_tree.h"
|
|
#include "scene/main/window.h"
|
|
|
|
namespace TestScrollContainer {
|
|
|
|
TEST_CASE("[SceneTree][ScrollContainer] Default behavior") {
|
|
ScrollContainer *test_container = memnew(ScrollContainer);
|
|
Window *root = SceneTree::get_singleton()->get_root();
|
|
root->add_child(test_container);
|
|
|
|
Control *test_control = memnew(Control);
|
|
test_control->set_custom_minimum_size(Size2(20, 20));
|
|
test_container->add_child(test_control);
|
|
|
|
test_container->set_size(Size2(100, 100));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_horizontal_scroll_mode() == ScrollContainer::SCROLL_MODE_AUTO,
|
|
"Horizontal scroll mode is SCROLL_MODE_AUTO by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_vertical_scroll_mode() == ScrollContainer::SCROLL_MODE_AUTO,
|
|
"Vertical scroll mode is SCROLL_MODE_AUTO by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_scroll_hint_mode() == ScrollContainer::SCROLL_HINT_MODE_DISABLED,
|
|
"Scroll hint mode is SCROLL_HINT_MODE_DISABLED by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->is_scroll_hint_tiled(),
|
|
"tile_scroll_hint is disabled by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->is_following_focus(),
|
|
"follow_focus is disabled by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->is_scroll_horizontal_by_default(),
|
|
"scroll_horizontal_by_default is disabled by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_draw_focus_border(),
|
|
"draw_focus_border is disabled by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->is_clipping_contents(),
|
|
"clip_contents is enabled by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_h_scroll() == 0,
|
|
"Horizontal scroll starts at 0 by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_v_scroll() == 0,
|
|
"Vertical scroll starts at 0 by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_h_scroll_bar() != nullptr,
|
|
"Horizontal scrollbar is created by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_v_scroll_bar() != nullptr,
|
|
"Vertical scrollbar is created by default.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_h_scroll_bar()->is_visible(),
|
|
"Horizontal scrollbar is hidden in auto mode when content fits.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_v_scroll_bar()->is_visible(),
|
|
"Vertical scrollbar is hidden in auto mode when content fits.");
|
|
|
|
memdelete(test_control);
|
|
memdelete(test_container);
|
|
}
|
|
|
|
TEST_CASE("[SceneTree][ScrollContainer] Scroll modes") {
|
|
ScrollContainer *test_container = memnew(ScrollContainer);
|
|
Window *root = SceneTree::get_singleton()->get_root();
|
|
root->add_child(test_container);
|
|
Control *test_control = memnew(Control);
|
|
test_container->add_child(test_control);
|
|
test_control->set_custom_minimum_size(Size2(100, 100));
|
|
Control *target_control = memnew(Control);
|
|
target_control->set_custom_minimum_size(Size2(20, 20));
|
|
target_control->set_position(Point2(80, 80));
|
|
target_control->set_size(Size2(20, 20));
|
|
test_control->add_child(target_control);
|
|
|
|
test_container->set_size(Size2(50, 50));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_h_scroll_bar()->is_visible(),
|
|
"H Scrollbar displays when ScrollContainer width is smaller than contents width with SCROLL_MODE_AUTO.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_v_scroll_bar()->is_visible(),
|
|
"V Scrollbar displays when ScrollContainer height is smaller than contents height with SCROLL_MODE_AUTO.");
|
|
|
|
test_container->set_size(Size2(150, 150));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_h_scroll_bar()->is_visible(),
|
|
"H Scrollbar does not display when ScrollContainer width is larger than contents width with SCROLL_MODE_AUTO.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_v_scroll_bar()->is_visible(),
|
|
"V Scrollbar does not display when ScrollContainer height is larger than contents height with SCROLL_MODE_AUTO.");
|
|
|
|
test_container->set_horizontal_scroll_mode(ScrollContainer::SCROLL_MODE_DISABLED);
|
|
test_container->set_vertical_scroll_mode(ScrollContainer::SCROLL_MODE_DISABLED);
|
|
|
|
test_container->set_size(Size2(50, 50));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_h_scroll_bar()->is_visible(),
|
|
"H Scrollbar does not display when ScrollContainer width is smaller than contents width with SCROLL_MODE_DISABLED.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_v_scroll_bar()->is_visible(),
|
|
"V Scrollbar does not display when ScrollContainer height is smaller than contents height with SCROLL_MODE_DISABLED.");
|
|
|
|
test_container->set_h_scroll(0);
|
|
test_container->set_v_scroll(0);
|
|
int disabled_h_scroll_before = test_container->get_h_scroll();
|
|
int disabled_v_scroll_before = test_container->get_v_scroll();
|
|
test_container->ensure_control_visible(target_control);
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_h_scroll() == disabled_h_scroll_before,
|
|
"SCROLL_MODE_DISABLED does not change horizontal scroll when ensure_control_visible() targets an out-of-view descendant.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_v_scroll() == disabled_v_scroll_before,
|
|
"SCROLL_MODE_DISABLED does not change vertical scroll when ensure_control_visible() targets an out-of-view descendant.");
|
|
|
|
test_container->set_h_scroll(0);
|
|
test_container->set_v_scroll(0);
|
|
|
|
test_container->set_size(Size2(150, 150));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_h_scroll_bar()->is_visible(),
|
|
"H Scrollbar does not display when ScrollContainer width is larger than contents width with SCROLL_MODE_DISABLED.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_v_scroll_bar()->is_visible(),
|
|
"V Scrollbar does not display when ScrollContainer height is larger than contents height with SCROLL_MODE_DISABLED.");
|
|
|
|
test_container->set_horizontal_scroll_mode(ScrollContainer::SCROLL_MODE_SHOW_ALWAYS);
|
|
test_container->set_vertical_scroll_mode(ScrollContainer::SCROLL_MODE_SHOW_ALWAYS);
|
|
|
|
test_container->set_size(Size2(50, 50));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_h_scroll_bar()->is_visible(),
|
|
"H Scrollbar displays when ScrollContainer width is smaller than contents width with SCROLL_MODE_SHOW_ALWAYS.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_v_scroll_bar()->is_visible(),
|
|
"V Scrollbar displays when ScrollContainer height is smaller than contents height with SCROLL_MODE_SHOW_ALWAYS.");
|
|
|
|
test_container->set_size(Size2(150, 150));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_h_scroll_bar()->is_visible(),
|
|
"H Scrollbar displays when ScrollContainer width is larger than contents width with SCROLL_MODE_SHOW_ALWAYS.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_v_scroll_bar()->is_visible(),
|
|
"V Scrollbar displays when ScrollContainer height is larger than contents height with SCROLL_MODE_SHOW_ALWAYS.");
|
|
|
|
test_container->set_horizontal_scroll_mode(ScrollContainer::SCROLL_MODE_SHOW_NEVER);
|
|
test_container->set_vertical_scroll_mode(ScrollContainer::SCROLL_MODE_SHOW_NEVER);
|
|
|
|
test_container->set_size(Size2(50, 50));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_h_scroll_bar()->is_visible(),
|
|
"H Scrollbar does not display when ScrollContainer width is smaller than contents width with SCROLL_MODE_SHOW_NEVER.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_v_scroll_bar()->is_visible(),
|
|
"V Scrollbar does not display when ScrollContainer height is smaller than contents height with SCROLL_MODE_SHOW_NEVER.");
|
|
|
|
test_container->set_h_scroll(0);
|
|
test_container->set_v_scroll(0);
|
|
int show_never_h_scroll_before = test_container->get_h_scroll();
|
|
int show_never_v_scroll_before = test_container->get_v_scroll();
|
|
test_container->ensure_control_visible(target_control);
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_h_scroll() > show_never_h_scroll_before,
|
|
"SCROLL_MODE_SHOW_NEVER keeps horizontal scrollbar hidden while still allowing programmatic scrolling.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_v_scroll() > show_never_v_scroll_before,
|
|
"SCROLL_MODE_SHOW_NEVER keeps vertical scrollbar hidden while still allowing programmatic scrolling.");
|
|
|
|
test_container->set_h_scroll(0);
|
|
test_container->set_v_scroll(0);
|
|
|
|
test_container->set_size(Size2(150, 150));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_h_scroll_bar()->is_visible(),
|
|
"H Scrollbar does not display when ScrollContainer width is larger than contents width with SCROLL_MODE_SHOW_NEVER.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_v_scroll_bar()->is_visible(),
|
|
"V Scrollbar does not display when ScrollContainer height is larger than contents height with SCROLL_MODE_SHOW_NEVER.");
|
|
|
|
test_container->set_horizontal_scroll_mode(ScrollContainer::SCROLL_MODE_RESERVE);
|
|
test_container->set_vertical_scroll_mode(ScrollContainer::SCROLL_MODE_RESERVE);
|
|
|
|
test_container->set_size(Size2(50, 50));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_h_scroll_bar()->is_visible(),
|
|
"H Scrollbar displays when ScrollContainer width is smaller than contents width with SCROLL_MODE_RESERVE.");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_v_scroll_bar()->is_visible(),
|
|
"V Scrollbar displays when ScrollContainer height is smaller than contents height with SCROLL_MODE_RESERVE.");
|
|
|
|
test_container->set_size(Size2(150, 150));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_h_scroll_bar()->is_visible(),
|
|
"H Scrollbar does not display when ScrollContainer width is larger than contents width with SCROLL_MODE_RESERVE.");
|
|
|
|
CHECK_MESSAGE(
|
|
!test_container->get_v_scroll_bar()->is_visible(),
|
|
"V Scrollbar does not display when ScrollContainer height is larger than contents height with SCROLL_MODE_RESERVE.");
|
|
|
|
memdelete(test_control);
|
|
memdelete(test_container);
|
|
}
|
|
|
|
TEST_CASE("[SceneTree][ScrollContainer] Scroll values and property setters") {
|
|
ScrollContainer *test_container = memnew(ScrollContainer);
|
|
Window *root = SceneTree::get_singleton()->get_root();
|
|
root->add_child(test_container);
|
|
|
|
Control *test_control = memnew(Control);
|
|
test_control->set_custom_minimum_size(Size2(300, 300));
|
|
test_container->add_child(test_control);
|
|
|
|
test_container->set_size(Size2(100, 100));
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
test_container->set_h_scroll(25);
|
|
test_container->set_v_scroll(35);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_h_scroll() == 25,
|
|
"Horizontal scroll value is updated by set_h_scroll().");
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_v_scroll() == 35,
|
|
"Vertical scroll value is updated by set_v_scroll().");
|
|
|
|
test_container->set_horizontal_custom_step(7.0f);
|
|
test_container->set_vertical_custom_step(9.0f);
|
|
|
|
CHECK_MESSAGE(
|
|
Math::is_equal_approx(test_container->get_horizontal_custom_step(), 7.0f),
|
|
"Horizontal custom step is updated correctly.");
|
|
|
|
CHECK_MESSAGE(
|
|
Math::is_equal_approx(test_container->get_vertical_custom_step(), 9.0f),
|
|
"Vertical custom step is updated correctly.");
|
|
|
|
test_container->set_deadzone(13);
|
|
CHECK_MESSAGE(
|
|
test_container->get_deadzone() == 13,
|
|
"Deadzone value is updated correctly.");
|
|
|
|
test_container->set_scroll_horizontal_by_default(true);
|
|
CHECK_MESSAGE(
|
|
test_container->is_scroll_horizontal_by_default(),
|
|
"scroll_horizontal_by_default is enabled correctly.");
|
|
|
|
test_container->set_follow_focus(true);
|
|
CHECK_MESSAGE(
|
|
test_container->is_following_focus(),
|
|
"follow_focus is enabled correctly.");
|
|
|
|
test_container->set_scroll_hint_mode(ScrollContainer::SCROLL_HINT_MODE_ALL);
|
|
CHECK_MESSAGE(
|
|
test_container->get_scroll_hint_mode() == ScrollContainer::SCROLL_HINT_MODE_ALL,
|
|
"Scroll hint mode is updated correctly.");
|
|
|
|
test_container->set_tile_scroll_hint(true);
|
|
CHECK_MESSAGE(
|
|
test_container->is_scroll_hint_tiled(),
|
|
"Tiled scroll hint mode is enabled correctly.");
|
|
|
|
test_container->set_draw_focus_border(true);
|
|
CHECK_MESSAGE(
|
|
test_container->get_draw_focus_border(),
|
|
"draw_focus_border is enabled correctly.");
|
|
|
|
memdelete(test_control);
|
|
memdelete(test_container);
|
|
}
|
|
|
|
TEST_CASE("[SceneTree][ScrollContainer] ensure_control_visible and follow_focus") {
|
|
const Size2 container_size = Size2(100, 100);
|
|
ScrollContainer *test_container = memnew(ScrollContainer);
|
|
test_container->set_size(container_size);
|
|
Window *root = SceneTree::get_singleton()->get_root();
|
|
root->add_child(test_container);
|
|
|
|
Control *content_control = memnew(Control);
|
|
content_control->set_custom_minimum_size(Size2(1000, 1000));
|
|
test_container->add_child(content_control);
|
|
|
|
Control *target_control = memnew(Control);
|
|
target_control->set_focus_mode(Control::FOCUS_ALL);
|
|
|
|
content_control->add_child(target_control);
|
|
|
|
REQUIRE_EQ(test_container->get_h_scroll(), 0);
|
|
REQUIRE_EQ(test_container->get_v_scroll(), 0);
|
|
|
|
SceneTree::get_singleton()->process(0);
|
|
|
|
const Point2 initial_scroll = Point2(450, 450);
|
|
test_container->set_h_scroll(initial_scroll.x);
|
|
test_container->set_v_scroll(initial_scroll.y);
|
|
|
|
SceneTree::get_singleton()->process(0);
|
|
REQUIRE_EQ(test_container->get_h_scroll(), initial_scroll.x);
|
|
REQUIRE_EQ(test_container->get_v_scroll(), initial_scroll.y);
|
|
REQUIRE_UNARY(test_container->get_h_scroll_bar()->is_visible_in_tree());
|
|
REQUIRE_UNARY(test_container->get_v_scroll_bar()->is_visible_in_tree());
|
|
REQUIRE_UNARY_FALSE(test_container->is_following_focus());
|
|
REQUIRE_UNARY_FALSE(target_control->has_focus());
|
|
|
|
SUBCASE("No scrolling when focused by default") {
|
|
target_control->grab_focus();
|
|
REQUIRE_UNARY(target_control->has_focus());
|
|
CHECK_EQ(test_container->get_h_scroll(), initial_scroll.x);
|
|
CHECK_EQ(test_container->get_v_scroll(), initial_scroll.y);
|
|
}
|
|
|
|
SUBCASE("Scrolling when ensure control visible by default") {
|
|
test_container->ensure_control_visible(target_control);
|
|
CHECK_EQ(test_container->get_h_scroll(), 0);
|
|
CHECK_EQ(test_container->get_v_scroll(), 0);
|
|
}
|
|
|
|
test_container->set_follow_focus(true);
|
|
REQUIRE_UNARY(test_container->is_following_focus());
|
|
|
|
const char *size_cases[2] = {
|
|
"The target control size is 50% of the container size",
|
|
"The target control size is 150% of the container size",
|
|
};
|
|
|
|
const char *location_cases[9] = {
|
|
"Target control is in the upper left corner",
|
|
"Target control is directly above",
|
|
"Target control is in the upper right corner",
|
|
"Target control is on the left",
|
|
"Target control is in the center",
|
|
"Target control is on the right",
|
|
"Target control is in the lower left corner",
|
|
"Target control is directly below",
|
|
"Target control is in the lower right corner",
|
|
};
|
|
const Size2 scroll_bar_space = Size2(test_container->get_v_scroll_bar()->get_size().x, test_container->get_h_scroll_bar()->get_size().y);
|
|
|
|
for (int size_case_idx = 0; size_case_idx < 2; size_case_idx++) {
|
|
SUBCASE(size_cases[size_case_idx]) {
|
|
Size2 control_size = container_size / 2 + size_case_idx * container_size;
|
|
target_control->set_size(control_size);
|
|
REQUIRE_EQ(target_control->get_size(), control_size);
|
|
int size_flag = 2 * size_case_idx - 1; // Map 0~1 to -1~1.
|
|
|
|
for (int location_case_idx = 0; location_case_idx < 9; location_case_idx++) {
|
|
Point2i location_flag = Point2i(location_case_idx % 3 - 1, location_case_idx / 3 - 1);
|
|
// Ensure that the numeric type and the get_*_scroll value are of the same type.
|
|
Point2i control_position;
|
|
Point2i expected_scroll;
|
|
|
|
for (int axis = 0; axis < 2; axis++) {
|
|
real_t size_offset = (size_flag == -1) ? control_size[axis] / 2 : -control_size[axis] / 4; // The effect of size on offset.
|
|
control_position[axis] = initial_scroll[axis] + size_offset + location_flag[axis] * container_size[axis] * 3;
|
|
// The situation is reversed when the size is large versus when it is small.
|
|
const int com_flag = size_flag * location_flag[axis];
|
|
if (com_flag == 1) {
|
|
expected_scroll[axis] = control_position[axis];
|
|
} else if (com_flag == 0) {
|
|
expected_scroll[axis] = initial_scroll[axis];
|
|
} else if (com_flag == -1) {
|
|
expected_scroll[axis] = control_position[axis] + control_size[axis] - container_size[axis] + scroll_bar_space[axis];
|
|
}
|
|
}
|
|
SUBCASE(location_cases[location_case_idx]) {
|
|
target_control->set_position(control_position);
|
|
REQUIRE_EQ(target_control->get_position(), control_position);
|
|
|
|
SUBCASE("Scrolling when grab focus") {
|
|
REQUIRE_EQ(test_container->get_h_scroll(), initial_scroll.x);
|
|
REQUIRE_EQ(test_container->get_v_scroll(), initial_scroll.y);
|
|
REQUIRE_UNARY_FALSE(target_control->has_focus());
|
|
target_control->grab_focus();
|
|
REQUIRE_UNARY(target_control->has_focus());
|
|
CHECK_EQ(test_container->get_h_scroll(), expected_scroll.x);
|
|
CHECK_EQ(test_container->get_v_scroll(), expected_scroll.y);
|
|
}
|
|
|
|
SUBCASE("Scrolling when ensure control visible") {
|
|
REQUIRE_EQ(test_container->get_h_scroll(), initial_scroll.x);
|
|
REQUIRE_EQ(test_container->get_v_scroll(), initial_scroll.y);
|
|
test_container->ensure_control_visible(target_control);
|
|
CHECK_EQ(test_container->get_h_scroll(), expected_scroll.x);
|
|
CHECK_EQ(test_container->get_v_scroll(), expected_scroll.y);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
memdelete(target_control);
|
|
memdelete(content_control);
|
|
memdelete(test_container);
|
|
}
|
|
|
|
TEST_CASE("[SceneTree][ScrollContainer] Configuration warnings") {
|
|
ScrollContainer *test_container = memnew(ScrollContainer);
|
|
Window *root = SceneTree::get_singleton()->get_root();
|
|
root->add_child(test_container);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_configuration_warnings().size() == 1,
|
|
"ScrollContainer reports one configuration warning when it has no content child.");
|
|
|
|
Control *child_control_1 = memnew(Control);
|
|
Control *child_control_2 = memnew(Control);
|
|
test_container->add_child(child_control_1);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_configuration_warnings().is_empty(),
|
|
"ScrollContainer reports no configuration warning when it has exactly one content child.");
|
|
|
|
test_container->add_child(child_control_2);
|
|
|
|
CHECK_MESSAGE(
|
|
test_container->get_configuration_warnings().size() == 1,
|
|
"ScrollContainer reports one configuration warning when it has more than one content child.");
|
|
|
|
memdelete(child_control_2);
|
|
memdelete(child_control_1);
|
|
memdelete(test_container);
|
|
}
|
|
|
|
} // namespace TestScrollContainer
|