Edgaru089/SFML
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Switch to Catch2

Browse Source
This commit is contained in:
Chris Thrasher 2023-01-17 21:51:08 -07:00
parent b14d0b47e6
commit f6dfc04938
48 changed files with 1451 additions and 1402 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.clang-format
View File

@ -112,7 +112,7 @@ IncludeCategories:
- Priority: 8 - Priority: 8
Regex: '^<SFML\/System' Regex: '^<SFML\/System'
- Priority: 9 - Priority: 9
Regex: '^<(glad|gl|X11|jni|android|stb_|GLES2|vorbis|doctest)' Regex: '^<(glad|gl|X11|jni|android|stb_|GLES2|vorbis|catch2)'
- Priority: 10 - Priority: 10
Regex: '^<([^c](.+)|coroutine|charconv|chrono|complex|concepts|condition_variable)>$' Regex: '^<([^c](.+)|coroutine|charconv|chrono|complex|concepts|condition_variable)>$'
- Priority: 11 - Priority: 11

4
.github/workflows/ci.yml vendored
View File

@ -139,13 +139,13 @@ jobs:
if [ "${{ runner.os }}" == "Windows" ]; then if [ "${{ runner.os }}" == "Windows" ]; then
# Make use of a test to print OpenGL vendor/renderer/version info to the console # Make use of a test to print OpenGL vendor/renderer/version info to the console
# We have to convert the backslashes in $GITHUB_WORKSPACE to (forward) slashes so bash doesn't try to escape them in the sh command # We have to convert the backslashes in $GITHUB_WORKSPACE to (forward) slashes so bash doesn't try to escape them in the sh command
find $(echo $GITHUB_WORKSPACE | sed 's/\\\\/\\//g')/build/bin -name test-sfml-window.exe -exec sh -c "{} --test-case=\"[Window] sf::Context\" --subcase=\"Version String\" | grep OpenGL" \; find $(echo $GITHUB_WORKSPACE | sed 's/\\\\/\\//g')/build/bin -name test-sfml-window.exe -exec sh -c "{} *sf::Context* --section=\"Version String\" --success | grep OpenGL" \;
# Run the tests # Run the tests
cmake --build $GITHUB_WORKSPACE/build --target runtests --config ${{ matrix.type.name == 'Debug' && 'Debug' || 'Release' }} cmake --build $GITHUB_WORKSPACE/build --target runtests --config ${{ matrix.type.name == 'Debug' && 'Debug' || 'Release' }}
# Coverage is already generated on Windows when running tests. # Coverage is already generated on Windows when running tests.
else else
# Make use of a test to print OpenGL vendor/renderer/version info to the console # Make use of a test to print OpenGL vendor/renderer/version info to the console
find $GITHUB_WORKSPACE/build/bin -name test-sfml-window -exec sh -c "{} --test-case=\"[Window] sf::Context\" --subcase=\"Version String\" | grep OpenGL" \; find $GITHUB_WORKSPACE/build/bin -name test-sfml-window -exec sh -c "{} *sf::Context* --section=\"Version String\" --success | grep OpenGL" \;
# Run the tests # Run the tests
ctest --test-dir $GITHUB_WORKSPACE/build --output-on-failure -C ${{ matrix.type.name == 'Debug' && 'Debug' || 'Release' }} ctest --test-dir $GITHUB_WORKSPACE/build --output-on-failure -C ${{ matrix.type.name == 'Debug' && 'Debug' || 'Release' }}
# Run gcovr to extract coverage information from the test run # Run gcovr to extract coverage information from the test run

2
cmake/Macros.cmake
View File

@ -376,7 +376,7 @@ function(sfml_add_test target SOURCES DEPENDS)
endif() endif()
# Add the test # Add the test
doctest_discover_tests(${target}) catch_discover_tests(${target})
endfunction() endfunction()
# Find the requested package and make an INTERFACE library from it # Find the requested package and make an INTERFACE library from it

42
test/CMakeLists.txt
View File

@ -1,21 +1,24 @@
include(FetchContent) include(FetchContent)
set(DOCTEST_NO_INSTALL ON)
FetchContent_Declare(doctest
GIT_REPOSITORY https://github.com/doctest/doctest.git
GIT_TAG v2.4.9
)
FetchContent_MakeAvailable(doctest)
include(${doctest_SOURCE_DIR}/scripts/cmake/doctest.cmake)
# Ensure that doctest sources and headers are not analyzed by any tools
set_target_properties(doctest_with_main PROPERTIES COMPILE_OPTIONS "" EXPORT_COMPILE_COMMANDS OFF)
get_target_property(DOCTEST_INCLUDE_DIRS doctest INTERFACE_INCLUDE_DIRECTORIES)
target_include_directories(doctest SYSTEM INTERFACE ${DOCTEST_INCLUDE_DIRS})
add_subdirectory(install) add_subdirectory(install)
set_target_warnings(test-sfml-install) set_target_warnings(test-sfml-install)
set(CATCH_CONFIG_FAST_COMPILE ON)
FetchContent_Declare(Catch2
GIT_REPOSITORY https://github.com/catchorg/Catch2.git
GIT_TAG v3.3.2)
FetchContent_MakeAvailable(Catch2)
include(Catch)
# Build Catch2 in C++17 mode to enable C++17 features
target_compile_features(Catch2 PRIVATE cxx_std_17)
# Ensure that Catch2 sources and headers are not analyzed by any tools
set_target_properties(Catch2 PROPERTIES COMPILE_OPTIONS "" EXPORT_COMPILE_COMMANDS OFF)
set_target_properties(Catch2WithMain PROPERTIES EXPORT_COMPILE_COMMANDS OFF)
get_target_property(CATCH2_INCLUDE_DIRS Catch2 INTERFACE_INCLUDE_DIRECTORIES)
target_include_directories(Catch2 SYSTEM INTERFACE ${CATCH2_INCLUDE_DIRS})
add_library(sfml-test-main STATIC add_library(sfml-test-main STATIC
TestUtilities/SystemUtil.hpp TestUtilities/SystemUtil.hpp
TestUtilities/SystemUtil.cpp TestUtilities/SystemUtil.cpp
@ -25,10 +28,14 @@ add_library(sfml-test-main STATIC
TestUtilities/GraphicsUtil.cpp TestUtilities/GraphicsUtil.cpp
) )
target_include_directories(sfml-test-main PUBLIC TestUtilities) target_include_directories(sfml-test-main PUBLIC TestUtilities)
target_compile_definitions(sfml-test-main PUBLIC DOCTEST_CONFIG_REQUIRE_STRINGIFICATION_FOR_ALL_USED_TYPES) target_link_libraries(sfml-test-main PUBLIC SFML::System Catch2::Catch2WithMain)
target_link_libraries(sfml-test-main PUBLIC SFML::System doctest::doctest_with_main)
set_target_warnings(sfml-test-main) set_target_warnings(sfml-test-main)
sfml_set_option(SFML_RUN_DISPLAY_TESTS ON BOOL "TRUE to run tests that require a display, FALSE to ignore it")
if(SFML_RUN_DISPLAY_TESTS)
target_compile_definitions(sfml-test-main PRIVATE SFML_RUN_DISPLAY_TESTS)
endif()
set(SYSTEM_SRC set(SYSTEM_SRC
System/Angle.test.cpp System/Angle.test.cpp
System/Clock.test.cpp System/Clock.test.cpp
@ -50,8 +57,6 @@ target_compile_definitions(test-sfml-system PRIVATE
EXPECTED_SFML_VERSION_IS_RELEASE=$<IF:$<BOOL:${VERSION_IS_RELEASE}>,true,false> EXPECTED_SFML_VERSION_IS_RELEASE=$<IF:$<BOOL:${VERSION_IS_RELEASE}>,true,false>
) )
sfml_set_option(SFML_RUN_DISPLAY_TESTS ON BOOL "TRUE to run tests that require a display, FALSE to ignore it")
set(WINDOW_SRC set(WINDOW_SRC
Window/Context.test.cpp Window/Context.test.cpp
Window/ContextSettings.test.cpp Window/ContextSettings.test.cpp
@ -62,9 +67,6 @@ set(WINDOW_SRC
Window/WindowBase.test.cpp Window/WindowBase.test.cpp
) )
sfml_add_test(test-sfml-window "${WINDOW_SRC}" SFML::Window) sfml_add_test(test-sfml-window "${WINDOW_SRC}" SFML::Window)
if(SFML_RUN_DISPLAY_TESTS)
target_compile_definitions(test-sfml-window PRIVATE SFML_RUN_DISPLAY_TESTS)
endif()
set(GRAPHICS_SRC set(GRAPHICS_SRC
Graphics/BlendMode.test.cpp Graphics/BlendMode.test.cpp

33
test/Graphics/BlendMode.test.cpp
View File

@ -1,20 +1,23 @@
#include <SFML/Graphics/BlendMode.hpp> #include <SFML/Graphics/BlendMode.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::BlendMode>);
static_assert(std::is_copy_assignable_v<sf::BlendMode>);
static_assert(std::is_nothrow_move_constructible_v<sf::BlendMode>);
static_assert(std::is_nothrow_move_assignable_v<sf::BlendMode>);
TEST_CASE("[Graphics] sf::BlendMode") TEST_CASE("[Graphics] sf::BlendMode")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::BlendMode>);
STATIC_CHECK(std::is_copy_assignable_v<sf::BlendMode>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::BlendMode>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::BlendMode>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::BlendMode blendMode; const sf::BlendMode blendMode;
CHECK(blendMode.colorSrcFactor == sf::BlendMode::SrcAlpha); CHECK(blendMode.colorSrcFactor == sf::BlendMode::SrcAlpha);
@ -25,7 +28,7 @@ TEST_CASE("[Graphics] sf::BlendMode")
CHECK(blendMode.alphaEquation == sf::BlendMode::Add); CHECK(blendMode.alphaEquation == sf::BlendMode::Add);
} }
SUBCASE("Combined color and alpha constructor using default parameter") SECTION("Combined color and alpha constructor using default parameter")
{ {
const sf::BlendMode blendMode(sf::BlendMode::Zero, sf::BlendMode::SrcColor); const sf::BlendMode blendMode(sf::BlendMode::Zero, sf::BlendMode::SrcColor);
CHECK(blendMode.colorSrcFactor == sf::BlendMode::Zero); CHECK(blendMode.colorSrcFactor == sf::BlendMode::Zero);
@ -36,7 +39,7 @@ TEST_CASE("[Graphics] sf::BlendMode")
CHECK(blendMode.alphaEquation == sf::BlendMode::Add); CHECK(blendMode.alphaEquation == sf::BlendMode::Add);
} }
SUBCASE("Combined color and alpha constructor") SECTION("Combined color and alpha constructor")
{ {
const sf::BlendMode blendMode(sf::BlendMode::Zero, sf::BlendMode::SrcColor, sf::BlendMode::ReverseSubtract); const sf::BlendMode blendMode(sf::BlendMode::Zero, sf::BlendMode::SrcColor, sf::BlendMode::ReverseSubtract);
CHECK(blendMode.colorSrcFactor == sf::BlendMode::Zero); CHECK(blendMode.colorSrcFactor == sf::BlendMode::Zero);
@ -47,7 +50,7 @@ TEST_CASE("[Graphics] sf::BlendMode")
CHECK(blendMode.alphaEquation == sf::BlendMode::ReverseSubtract); CHECK(blendMode.alphaEquation == sf::BlendMode::ReverseSubtract);
} }
SUBCASE("Separate color and alpha constructor") SECTION("Separate color and alpha constructor")
{ {
const sf::BlendMode blendMode(sf::BlendMode::Zero, const sf::BlendMode blendMode(sf::BlendMode::Zero,
sf::BlendMode::SrcColor, sf::BlendMode::SrcColor,
@ -64,9 +67,9 @@ TEST_CASE("[Graphics] sf::BlendMode")
} }
} }
SUBCASE("Operators") SECTION("Operators")
{ {
SUBCASE("operator==") SECTION("operator==")
{ {
CHECK(sf::BlendMode() == sf::BlendMode()); CHECK(sf::BlendMode() == sf::BlendMode());
CHECK(sf::BlendMode(sf::BlendMode::Zero, sf::BlendMode::One) == CHECK(sf::BlendMode(sf::BlendMode::Zero, sf::BlendMode::One) ==
@ -102,7 +105,7 @@ TEST_CASE("[Graphics] sf::BlendMode")
sf::BlendMode::Max)); sf::BlendMode::Max));
} }
SUBCASE("operator!=") SECTION("operator!=")
{ {
CHECK_FALSE(sf::BlendMode() != sf::BlendMode()); CHECK_FALSE(sf::BlendMode() != sf::BlendMode());
CHECK_FALSE(sf::BlendMode(sf::BlendMode::Zero, sf::BlendMode::One) != CHECK_FALSE(sf::BlendMode(sf::BlendMode::Zero, sf::BlendMode::One) !=
@ -139,7 +142,7 @@ TEST_CASE("[Graphics] sf::BlendMode")
} }
} }
SUBCASE("Static constants") SECTION("Static constants")
{ {
CHECK(sf::BlendAlpha.colorSrcFactor == sf::BlendMode::SrcAlpha); CHECK(sf::BlendAlpha.colorSrcFactor == sf::BlendMode::SrcAlpha);
CHECK(sf::BlendAlpha.colorDstFactor == sf::BlendMode::OneMinusSrcAlpha); CHECK(sf::BlendAlpha.colorDstFactor == sf::BlendMode::OneMinusSrcAlpha);

27
test/Graphics/CircleShape.test.cpp
View File

@ -1,18 +1,21 @@
#include <SFML/Graphics/CircleShape.hpp> #include <SFML/Graphics/CircleShape.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <SystemUtil.hpp> #include <SystemUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::CircleShape>);
static_assert(std::is_copy_assignable_v<sf::CircleShape>);
static_assert(std::is_nothrow_move_constructible_v<sf::CircleShape>);
static_assert(std::is_nothrow_move_assignable_v<sf::CircleShape>);
TEST_CASE("[Graphics] sf::CircleShape") TEST_CASE("[Graphics] sf::CircleShape")
{ {
SUBCASE("Default constructor") SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::CircleShape>);
STATIC_CHECK(std::is_copy_assignable_v<sf::CircleShape>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::CircleShape>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::CircleShape>);
}
SECTION("Default constructor")
{ {
const sf::CircleShape circle; const sf::CircleShape circle;
CHECK(circle.getRadius() == 0.f); CHECK(circle.getRadius() == 0.f);
@ -21,7 +24,7 @@ TEST_CASE("[Graphics] sf::CircleShape")
CHECK(circle.getPoint(i) == sf::Vector2f(0, 0)); CHECK(circle.getPoint(i) == sf::Vector2f(0, 0));
} }
SUBCASE("Radius constructor") SECTION("Radius constructor")
{ {
const sf::CircleShape circle(15.f); const sf::CircleShape circle(15.f);
CHECK(circle.getRadius() == 15.f); CHECK(circle.getRadius() == 15.f);
@ -58,7 +61,7 @@ TEST_CASE("[Graphics] sf::CircleShape")
CHECK(circle.getPoint(29) == Approx(sf::Vector2f(11.881320953f, 0.327786446f))); CHECK(circle.getPoint(29) == Approx(sf::Vector2f(11.881320953f, 0.327786446f)));
} }
SUBCASE("Radius and point count constructor") SECTION("Radius and point count constructor")
{ {
const sf::CircleShape circle(5.f, 8); const sf::CircleShape circle(5.f, 8);
CHECK(circle.getRadius() == 5.f); CHECK(circle.getRadius() == 5.f);
@ -73,7 +76,7 @@ TEST_CASE("[Graphics] sf::CircleShape")
CHECK(circle.getPoint(7) == Approx(sf::Vector2f(1.464465857f, 1.464466572f))); CHECK(circle.getPoint(7) == Approx(sf::Vector2f(1.464465857f, 1.464466572f)));
} }
SUBCASE("Set radius") SECTION("Set radius")
{ {
sf::CircleShape circle(1.f, 6); sf::CircleShape circle(1.f, 6);
circle.setRadius(10.f); circle.setRadius(10.f);
@ -87,7 +90,7 @@ TEST_CASE("[Graphics] sf::CircleShape")
CHECK(circle.getPoint(5) == Approx(sf::Vector2f(1.339745522f, 5.000000000f))); CHECK(circle.getPoint(5) == Approx(sf::Vector2f(1.339745522f, 5.000000000f)));
} }
SUBCASE("Set point count") SECTION("Set point count")
{ {
sf::CircleShape circle(4.f, 10); sf::CircleShape circle(4.f, 10);
circle.setPointCount(4); circle.setPointCount(4);
@ -99,7 +102,7 @@ TEST_CASE("[Graphics] sf::CircleShape")
CHECK(circle.getPoint(3) == Approx(sf::Vector2f(0.000000000f, 3.999999762f))); CHECK(circle.getPoint(3) == Approx(sf::Vector2f(0.000000000f, 3.999999762f)));
} }
SUBCASE("Equilateral triangle") SECTION("Equilateral triangle")
{ {
const sf::CircleShape triangle(2.f, 3); const sf::CircleShape triangle(2.f, 3);
CHECK(triangle.getRadius() == 2.f); CHECK(triangle.getRadius() == 2.f);

176
test/Graphics/Color.test.cpp
View File

@ -1,112 +1,115 @@
#include <SFML/Graphics/Color.hpp> #include <SFML/Graphics/Color.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
static_assert(std::is_copy_constructible_v<sf::Color>);
static_assert(std::is_copy_assignable_v<sf::Color>);
static_assert(std::is_nothrow_move_constructible_v<sf::Color>);
static_assert(std::is_nothrow_move_assignable_v<sf::Color>);
TEST_CASE("[Graphics] sf::Color") TEST_CASE("[Graphics] sf::Color")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::Color>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Color>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Color>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Color>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::Color color; constexpr sf::Color color;
CHECK(color.r == 0); STATIC_CHECK(color.r == 0);
CHECK(color.g == 0); STATIC_CHECK(color.g == 0);
CHECK(color.b == 0); STATIC_CHECK(color.b == 0);
CHECK(color.a == 255); STATIC_CHECK(color.a == 255);
} }
SUBCASE("(r, g, b) constructor") SECTION("(r, g, b) constructor")
{ {
const sf::Color color(1, 2, 3); constexpr sf::Color color(1, 2, 3);
CHECK(color.r == 1); STATIC_CHECK(color.r == 1);
CHECK(color.g == 2); STATIC_CHECK(color.g == 2);
CHECK(color.b == 3); STATIC_CHECK(color.b == 3);
CHECK(color.a == 255); STATIC_CHECK(color.a == 255);
} }
SUBCASE("(r, g, b, a) constructor") SECTION("(r, g, b, a) constructor")
{ {
const sf::Color color(1, 2, 3, 4); constexpr sf::Color color(1, 2, 3, 4);
CHECK(color.r == 1); STATIC_CHECK(color.r == 1);
CHECK(color.g == 2); STATIC_CHECK(color.g == 2);
CHECK(color.b == 3); STATIC_CHECK(color.b == 3);
CHECK(color.a == 4); STATIC_CHECK(color.a == 4);
} }
SUBCASE("std::int32_t constructor") SECTION("std::int32_t constructor")
{ {
CHECK(sf::Color(0x00000000) == sf::Color(0, 0, 0, 0)); STATIC_CHECK(sf::Color(0x00000000) == sf::Color(0, 0, 0, 0));
CHECK(sf::Color(0x01020304) == sf::Color(1, 2, 3, 4)); STATIC_CHECK(sf::Color(0x01020304) == sf::Color(1, 2, 3, 4));
CHECK(sf::Color(0xFFFFFFFF) == sf::Color(255, 255, 255, 255)); STATIC_CHECK(sf::Color(0xFFFFFFFF) == sf::Color(255, 255, 255, 255));
} }
} }
SUBCASE("toInteger()") SECTION("toInteger()")
{ {
CHECK(sf::Color(0, 0, 0, 0).toInteger() == 0x00000000); STATIC_CHECK(sf::Color(0, 0, 0, 0).toInteger() == 0x00000000);
CHECK(sf::Color(1, 2, 3, 4).toInteger() == 0x01020304); STATIC_CHECK(sf::Color(1, 2, 3, 4).toInteger() == 0x01020304);
CHECK(sf::Color(255, 255, 255, 255).toInteger() == 0xFFFFFFFF); STATIC_CHECK(sf::Color(255, 255, 255, 255).toInteger() == 0xFFFFFFFF);
} }
SUBCASE("Operations") SECTION("Operations")
{ {
SUBCASE("operator==") SECTION("operator==")
{ {
CHECK(sf::Color() == sf::Color()); STATIC_CHECK(sf::Color() == sf::Color());
CHECK(sf::Color(1, 2, 3, 4) == sf::Color(1, 2, 3, 4)); STATIC_CHECK(sf::Color(1, 2, 3, 4) == sf::Color(1, 2, 3, 4));
CHECK_FALSE(sf::Color(1, 0, 0, 0) == sf::Color(0, 0, 0, 0)); STATIC_CHECK_FALSE(sf::Color(1, 0, 0, 0) == sf::Color(0, 0, 0, 0));
CHECK_FALSE(sf::Color(0, 1, 0, 0) == sf::Color(0, 0, 0, 0)); STATIC_CHECK_FALSE(sf::Color(0, 1, 0, 0) == sf::Color(0, 0, 0, 0));
CHECK_FALSE(sf::Color(0, 0, 1, 0) == sf::Color(0, 0, 0, 0)); STATIC_CHECK_FALSE(sf::Color(0, 0, 1, 0) == sf::Color(0, 0, 0, 0));
CHECK_FALSE(sf::Color(0, 0, 0, 1) == sf::Color(0, 0, 0, 0)); STATIC_CHECK_FALSE(sf::Color(0, 0, 0, 1) == sf::Color(0, 0, 0, 0));
} }
SUBCASE("operator!=") SECTION("operator!=")
{ {
CHECK(sf::Color(1, 0, 0, 0) != sf::Color(0, 0, 0, 0)); STATIC_CHECK(sf::Color(1, 0, 0, 0) != sf::Color(0, 0, 0, 0));
CHECK(sf::Color(0, 1, 0, 0) != sf::Color(0, 0, 0, 0)); STATIC_CHECK(sf::Color(0, 1, 0, 0) != sf::Color(0, 0, 0, 0));
CHECK(sf::Color(0, 0, 1, 0) != sf::Color(0, 0, 0, 0)); STATIC_CHECK(sf::Color(0, 0, 1, 0) != sf::Color(0, 0, 0, 0));
CHECK(sf::Color(0, 0, 0, 1) != sf::Color(0, 0, 0, 0)); STATIC_CHECK(sf::Color(0, 0, 0, 1) != sf::Color(0, 0, 0, 0));
CHECK_FALSE(sf::Color() != sf::Color()); STATIC_CHECK_FALSE(sf::Color() != sf::Color());
CHECK_FALSE(sf::Color(1, 2, 3, 4) != sf::Color(1, 2, 3, 4)); STATIC_CHECK_FALSE(sf::Color(1, 2, 3, 4) != sf::Color(1, 2, 3, 4));
} }
SUBCASE("operator+") SECTION("operator+")
{ {
CHECK(sf::Color(0, 0, 0, 0) + sf::Color(0, 0, 0, 0) == sf::Color(0, 0, 0, 0)); STATIC_CHECK(sf::Color(0, 0, 0, 0) + sf::Color(0, 0, 0, 0) == sf::Color(0, 0, 0, 0));
CHECK(sf::Color(50, 50, 50, 50) + sf::Color(50, 50, 50, 50) == sf::Color(100, 100, 100, 100)); STATIC_CHECK(sf::Color(50, 50, 50, 50) + sf::Color(50, 50, 50, 50) == sf::Color(100, 100, 100, 100));
CHECK(sf::Color(100, 100, 100, 100) + sf::Color(100, 100, 100, 100) == sf::Color(200, 200, 200, 200)); STATIC_CHECK(sf::Color(100, 100, 100, 100) + sf::Color(100, 100, 100, 100) == sf::Color(200, 200, 200, 200));
CHECK(sf::Color(150, 150, 150, 150) + sf::Color(150, 150, 150, 150) == sf::Color(255, 255, 255, 255)); STATIC_CHECK(sf::Color(150, 150, 150, 150) + sf::Color(150, 150, 150, 150) == sf::Color(255, 255, 255, 255));
CHECK(sf::Color(255, 255, 255, 255) + sf::Color(255, 255, 255, 255) == sf::Color(255, 255, 255, 255)); STATIC_CHECK(sf::Color(255, 255, 255, 255) + sf::Color(255, 255, 255, 255) == sf::Color(255, 255, 255, 255));
} }
SUBCASE("operator-") SECTION("operator-")
{ {
const sf::Color c(50, 50, 50, 50); constexpr sf::Color c(50, 50, 50, 50);
const sf::Color c2(150, 150, 150, 150); constexpr sf::Color c2(150, 150, 150, 150);
CHECK(c2 - c == sf::Color(100, 100, 100, 100)); STATIC_CHECK(c2 - c == sf::Color(100, 100, 100, 100));
CHECK(c - c2 == sf::Color(0, 0, 0, 0)); STATIC_CHECK(c - c2 == sf::Color(0, 0, 0, 0));
} }
SUBCASE("operator*") SECTION("operator*")
{ {
const sf::Color c(255, 255, 255, 255); constexpr sf::Color c(255, 255, 255, 255);
const sf::Color c2(2, 2, 2, 2); constexpr sf::Color c2(2, 2, 2, 2);
CHECK(c * c2 == sf::Color(2, 2, 2, 2)); STATIC_CHECK(c * c2 == sf::Color(2, 2, 2, 2));
CHECK(c2 * c == sf::Color(2, 2, 2, 2)); STATIC_CHECK(c2 * c == sf::Color(2, 2, 2, 2));
} }
SUBCASE("operator+=") SECTION("operator+=")
{ {
sf::Color color(42, 42, 42, 42); sf::Color color(42, 42, 42, 42);
color += sf::Color(1, 1, 1, 1); color += sf::Color(1, 1, 1, 1);
@ -115,7 +118,7 @@ TEST_CASE("[Graphics] sf::Color")
CHECK(color == sf::Color(255, 255, 255, 255)); CHECK(color == sf::Color(255, 255, 255, 255));
} }
SUBCASE("operator-=") SECTION("operator-=")
{ {
sf::Color color(248, 248, 248, 248); sf::Color color(248, 248, 248, 248);
color -= sf::Color(1, 1, 1, 1); color -= sf::Color(1, 1, 1, 1);
@ -124,7 +127,7 @@ TEST_CASE("[Graphics] sf::Color")
CHECK(color == sf::Color(0, 0, 0, 0)); CHECK(color == sf::Color(0, 0, 0, 0));
} }
SUBCASE("operator*=") SECTION("operator*=")
{ {
sf::Color color(50, 50, 50, 50); sf::Color color(50, 50, 50, 50);
color *= sf::Color(20, 20, 20, 20); color *= sf::Color(20, 20, 20, 20);
@ -134,36 +137,23 @@ TEST_CASE("[Graphics] sf::Color")
} }
} }
SUBCASE("Constants") SECTION("Constants")
{ {
CHECK(sf::Color::Black == sf::Color(0, 0, 0)); STATIC_CHECK(sf::Color::Black == sf::Color(0, 0, 0));
CHECK(sf::Color::White == sf::Color(255, 255, 255)); STATIC_CHECK(sf::Color::White == sf::Color(255, 255, 255));
CHECK(sf::Color::Red == sf::Color(255, 0, 0)); STATIC_CHECK(sf::Color::Red == sf::Color(255, 0, 0));
CHECK(sf::Color::Green == sf::Color(0, 255, 0)); STATIC_CHECK(sf::Color::Green == sf::Color(0, 255, 0));
CHECK(sf::Color::Blue == sf::Color(0, 0, 255)); STATIC_CHECK(sf::Color::Blue == sf::Color(0, 0, 255));
CHECK(sf::Color::Yellow == sf::Color(255, 255, 0)); STATIC_CHECK(sf::Color::Yellow == sf::Color(255, 255, 0));
CHECK(sf::Color::Magenta == sf::Color(255, 0, 255)); STATIC_CHECK(sf::Color::Magenta == sf::Color(255, 0, 255));
CHECK(sf::Color::Cyan == sf::Color(0, 255, 255)); STATIC_CHECK(sf::Color::Cyan == sf::Color(0, 255, 255));
CHECK(sf::Color::Transparent == sf::Color(0, 0, 0, 0)); STATIC_CHECK(sf::Color::Transparent == sf::Color(0, 0, 0, 0));
} }
SUBCASE("Constexpr support") SECTION("Reinterpret as std::uint8_t*")
{ {
constexpr sf::Color color(1, 2, 3, 4); STATIC_CHECK(sizeof(sf::Color) == 4);
static_assert(color.r == 1); STATIC_CHECK(alignof(sf::Color) == 1);
static_assert(color.g == 2);
static_assert(color.b == 3);
static_assert(color.a == 4);
static_assert(color + color == sf::Color(2, 4, 6, 8));
static_assert(sf::Color::Black == sf::Color(0, 0, 0, 255));
}
SUBCASE("Reinterpret as std::uint8_t*")
{
static_assert(sizeof(sf::Color) == 4);
static_assert(alignof(sf::Color) == 1);
const std::vector<sf::Color> pixels = {{10, 11, 12, 13}, {14, 15, 16, 17}, {18, 19, 20, 21}}; const std::vector<sf::Color> pixels = {{10, 11, 12, 13}, {14, 15, 16, 17}, {18, 19, 20, 21}};
const auto* begin = reinterpret_cast<const std::uint8_t*>(pixels.data()); const auto* begin = reinterpret_cast<const std::uint8_t*>(pixels.data());

23
test/Graphics/ConvexShape.test.cpp
View File

@ -1,24 +1,27 @@
#include <SFML/Graphics/ConvexShape.hpp> #include <SFML/Graphics/ConvexShape.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <SystemUtil.hpp> #include <SystemUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::ConvexShape>);
static_assert(std::is_copy_assignable_v<sf::ConvexShape>);
static_assert(std::is_nothrow_move_constructible_v<sf::ConvexShape>);
static_assert(std::is_nothrow_move_assignable_v<sf::ConvexShape>);
TEST_CASE("[Graphics] sf::ConvexShape") TEST_CASE("[Graphics] sf::ConvexShape")
{ {
SUBCASE("Default constructor") SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::ConvexShape>);
STATIC_CHECK(std::is_copy_assignable_v<sf::ConvexShape>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::ConvexShape>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::ConvexShape>);
}
SECTION("Default constructor")
{ {
const sf::ConvexShape convex; const sf::ConvexShape convex;
CHECK(convex.getPointCount() == 0); CHECK(convex.getPointCount() == 0);
} }
SUBCASE("Point count constructor") SECTION("Point count constructor")
{ {
const sf::ConvexShape convex(15); const sf::ConvexShape convex(15);
CHECK(convex.getPointCount() == 15); CHECK(convex.getPointCount() == 15);
@ -26,7 +29,7 @@ TEST_CASE("[Graphics] sf::ConvexShape")
CHECK(convex.getPoint(i) == sf::Vector2f(0, 0)); CHECK(convex.getPoint(i) == sf::Vector2f(0, 0));
} }
SUBCASE("Set point count") SECTION("Set point count")
{ {
sf::ConvexShape convex; sf::ConvexShape convex;
convex.setPointCount(42); convex.setPointCount(42);
@ -35,7 +38,7 @@ TEST_CASE("[Graphics] sf::ConvexShape")
CHECK(convex.getPoint(i) == sf::Vector2f(0, 0)); CHECK(convex.getPoint(i) == sf::Vector2f(0, 0));
} }
SUBCASE("Set point") SECTION("Set point")
{ {
sf::ConvexShape convex; sf::ConvexShape convex;
convex.setPointCount(1); convex.setPointCount(1);

27
test/Graphics/Drawable.test.cpp
View File

@ -1,19 +1,11 @@
#include <SFML/Graphics/Drawable.hpp> #include <SFML/Graphics/Drawable.hpp>
#include <SFML/Graphics/RenderTexture.hpp> #include <SFML/Graphics/RenderTexture.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(!std::is_constructible_v<sf::Drawable>);
static_assert(!std::is_copy_constructible_v<sf::Drawable>);
static_assert(std::is_copy_assignable_v<sf::Drawable>);
static_assert(!std::is_nothrow_move_constructible_v<sf::Drawable>);
static_assert(std::is_nothrow_move_assignable_v<sf::Drawable>);
static_assert(std::is_abstract_v<sf::Drawable>);
static_assert(std::has_virtual_destructor_v<sf::Drawable>);
class DrawableTest : public sf::Drawable class DrawableTest : public sf::Drawable
{ {
public: public:
@ -31,15 +23,26 @@ private:
mutable int m_callCount{}; mutable int m_callCount{};
}; };
TEST_CASE("[Graphics] sf::Drawable" * doctest::skip(skipDisplayTests)) TEST_CASE("[Graphics] sf::Drawable", runDisplayTests())
{ {
SUBCASE("Construction") SECTION("Type traits")
{
STATIC_CHECK(!std::is_constructible_v<sf::Drawable>);
STATIC_CHECK(!std::is_copy_constructible_v<sf::Drawable>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Drawable>);
STATIC_CHECK(!std::is_nothrow_move_constructible_v<sf::Drawable>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Drawable>);
STATIC_CHECK(std::is_abstract_v<sf::Drawable>);
STATIC_CHECK(std::has_virtual_destructor_v<sf::Drawable>);
}
SECTION("Construction")
{ {
const DrawableTest drawableTest; const DrawableTest drawableTest;
CHECK(drawableTest.callCount() == 0); CHECK(drawableTest.callCount() == 0);
} }
SUBCASE("draw()") SECTION("draw()")
{ {
const DrawableTest drawableTest; const DrawableTest drawableTest;
sf::RenderTexture renderTexture; sf::RenderTexture renderTexture;

17
test/Graphics/Glyph.test.cpp
View File

@ -1,18 +1,21 @@
#include <SFML/Graphics/Glyph.hpp> #include <SFML/Graphics/Glyph.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::Glyph>);
static_assert(std::is_copy_assignable_v<sf::Glyph>);
static_assert(std::is_nothrow_move_constructible_v<sf::Glyph>);
static_assert(std::is_nothrow_move_assignable_v<sf::Glyph>);
TEST_CASE("[Graphics] sf::Glyph") TEST_CASE("[Graphics] sf::Glyph")
{ {
SUBCASE("Construction") SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::Glyph>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Glyph>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Glyph>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Glyph>);
}
SECTION("Construction")
{ {
const sf::Glyph glyph; const sf::Glyph glyph;
CHECK(glyph.advance == 0.f); CHECK(glyph.advance == 0.f);

49
test/Graphics/Image.test.cpp
View File

@ -1,28 +1,31 @@
#include <SFML/Graphics/Image.hpp> #include <SFML/Graphics/Image.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <array> #include <array>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::Image>);
static_assert(std::is_copy_assignable_v<sf::Image>);
static_assert(std::is_nothrow_move_constructible_v<sf::Image>);
static_assert(std::is_nothrow_move_assignable_v<sf::Image>);
TEST_CASE("[Graphics] sf::Image") TEST_CASE("[Graphics] sf::Image")
{ {
SUBCASE("Default constructor") SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::Image>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Image>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Image>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Image>);
}
SECTION("Default constructor")
{ {
const sf::Image image; const sf::Image image;
CHECK(image.getSize() == sf::Vector2u()); CHECK(image.getSize() == sf::Vector2u());
CHECK(image.getPixelsPtr() == nullptr); CHECK(image.getPixelsPtr() == nullptr);
} }
SUBCASE("Create") SECTION("Create")
{ {
SUBCASE("create(Vector2)") SECTION("create(Vector2)")
{ {
sf::Image image; sf::Image image;
image.create(sf::Vector2u(10, 10)); image.create(sf::Vector2u(10, 10));
@ -38,7 +41,7 @@ TEST_CASE("[Graphics] sf::Image")
} }
} }
SUBCASE("create(Vector2, Color)") SECTION("create(Vector2, Color)")
{ {
sf::Image image; sf::Image image;
image.create(sf::Vector2u(10, 10), sf::Color::Red); image.create(sf::Vector2u(10, 10), sf::Color::Red);
@ -55,7 +58,7 @@ TEST_CASE("[Graphics] sf::Image")
} }
} }
SUBCASE("create(Vector2, std::uint8_t*)") SECTION("create(Vector2, std::uint8_t*)")
{ {
// 10 x 10, with 4 colour channels array // 10 x 10, with 4 colour channels array
std::array<std::uint8_t, 400> pixels; std::array<std::uint8_t, 400> pixels;
@ -83,7 +86,7 @@ TEST_CASE("[Graphics] sf::Image")
} }
} }
SUBCASE("Set/get pixel") SECTION("Set/get pixel")
{ {
sf::Image image; sf::Image image;
@ -94,9 +97,9 @@ TEST_CASE("[Graphics] sf::Image")
CHECK(image.getPixel(sf::Vector2u(2, 2)) == sf::Color::Blue); CHECK(image.getPixel(sf::Vector2u(2, 2)) == sf::Color::Blue);
} }
SUBCASE("Copy from Image") SECTION("Copy from Image")
{ {
SUBCASE("Copy (Image, Vector2u)") SECTION("Copy (Image, Vector2u)")
{ {
sf::Image image1; sf::Image image1;
image1.create(sf::Vector2u(10, 10), sf::Color::Blue); image1.create(sf::Vector2u(10, 10), sf::Color::Blue);
@ -114,7 +117,7 @@ TEST_CASE("[Graphics] sf::Image")
} }
} }
SUBCASE("Copy (Image, Vector2u, IntRect)") SECTION("Copy (Image, Vector2u, IntRect)")
{ {
sf::Image image1; sf::Image image1;
image1.create(sf::Vector2u(5, 5), sf::Color::Blue); image1.create(sf::Vector2u(5, 5), sf::Color::Blue);
@ -135,7 +138,7 @@ TEST_CASE("[Graphics] sf::Image")
} }
} }
SUBCASE("Copy (Image, Vector2u, IntRect, bool)") SECTION("Copy (Image, Vector2u, IntRect, bool)")
{ {
const sf::Color dest(255, 0, 0, 255); const sf::Color dest(255, 0, 0, 255);
const sf::Color source(5, 255, 78, 232); const sf::Color source(5, 255, 78, 232);
@ -166,7 +169,7 @@ TEST_CASE("[Graphics] sf::Image")
} }
} }
SUBCASE("Copy (Empty image)") SECTION("Copy (Empty image)")
{ {
const sf::Image image1; const sf::Image image1;
sf::Image image2; sf::Image image2;
@ -183,7 +186,7 @@ TEST_CASE("[Graphics] sf::Image")
} }
} }
SUBCASE("Copy (Out of bounds sourceRect)") SECTION("Copy (Out of bounds sourceRect)")
{ {
sf::Image image1; sf::Image image1;
image1.create(sf::Vector2u(5, 5), sf::Color::Blue); image1.create(sf::Vector2u(5, 5), sf::Color::Blue);
@ -203,9 +206,9 @@ TEST_CASE("[Graphics] sf::Image")
} }
} }
SUBCASE("Create mask from color") SECTION("Create mask from color")
{ {
SUBCASE("createMaskFromColor(Color)") SECTION("createMaskFromColor(Color)")
{ {
sf::Image image; sf::Image image;
image.create(sf::Vector2u(10, 10), sf::Color::Blue); image.create(sf::Vector2u(10, 10), sf::Color::Blue);
@ -220,7 +223,7 @@ TEST_CASE("[Graphics] sf::Image")
} }
} }
SUBCASE("createMaskFromColor(Color, std::uint8_t)") SECTION("createMaskFromColor(Color, std::uint8_t)")
{ {
sf::Image image; sf::Image image;
image.create(sf::Vector2u(10, 10), sf::Color::Blue); image.create(sf::Vector2u(10, 10), sf::Color::Blue);
@ -236,7 +239,7 @@ TEST_CASE("[Graphics] sf::Image")
} }
} }
SUBCASE("Flip horizontally") SECTION("Flip horizontally")
{ {
sf::Image image; sf::Image image;
image.create(sf::Vector2u(10, 10), sf::Color::Red); image.create(sf::Vector2u(10, 10), sf::Color::Red);
@ -246,7 +249,7 @@ TEST_CASE("[Graphics] sf::Image")
CHECK(image.getPixel(sf::Vector2u(9, 0)) == sf::Color::Green); CHECK(image.getPixel(sf::Vector2u(9, 0)) == sf::Color::Green);
} }
SUBCASE("Flip vertically") SECTION("Flip vertically")
{ {
sf::Image image; sf::Image image;
image.create(sf::Vector2u(10, 10), sf::Color::Red); image.create(sf::Vector2u(10, 10), sf::Color::Red);

155
test/Graphics/Rect.test.cpp
View File

@ -2,126 +2,129 @@
#include <SFML/System/Vector2.hpp> #include <SFML/System/Vector2.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::IntRect>);
static_assert(std::is_copy_assignable_v<sf::IntRect>);
static_assert(std::is_nothrow_move_constructible_v<sf::IntRect>);
static_assert(std::is_nothrow_move_assignable_v<sf::IntRect>);
TEST_CASE("[Graphics] sf::Rect") TEST_CASE("[Graphics] sf::Rect")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::IntRect>);
STATIC_CHECK(std::is_copy_assignable_v<sf::IntRect>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::IntRect>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::IntRect>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::IntRect rectangle; constexpr sf::IntRect rectangle;
CHECK(rectangle.left == 0); STATIC_CHECK(rectangle.left == 0);
CHECK(rectangle.top == 0); STATIC_CHECK(rectangle.top == 0);
CHECK(rectangle.width == 0); STATIC_CHECK(rectangle.width == 0);
CHECK(rectangle.height == 0); STATIC_CHECK(rectangle.height == 0);
} }
SUBCASE("(left, top, width, height) constructor") SECTION("(left, top, width, height) constructor")
{ {
const sf::IntRect rectangle({1, 2}, {3, 4}); constexpr sf::IntRect rectangle({1, 2}, {3, 4});
CHECK(rectangle.left == 1); STATIC_CHECK(rectangle.left == 1);
CHECK(rectangle.top == 2); STATIC_CHECK(rectangle.top == 2);
CHECK(rectangle.width == 3); STATIC_CHECK(rectangle.width == 3);
CHECK(rectangle.height == 4); STATIC_CHECK(rectangle.height == 4);
} }
SUBCASE("(Vector2, Vector2) constructor") SECTION("(Vector2, Vector2) constructor")
{ {
const sf::Vector2i position(1, 2); constexpr sf::Vector2i position(1, 2);
const sf::Vector2i dimension(3, 4); constexpr sf::Vector2i dimension(3, 4);
const sf::IntRect rectangle(position, dimension); constexpr sf::IntRect rectangle(position, dimension);
CHECK(rectangle.left == 1); STATIC_CHECK(rectangle.left == 1);
CHECK(rectangle.top == 2); STATIC_CHECK(rectangle.top == 2);
CHECK(rectangle.width == 3); STATIC_CHECK(rectangle.width == 3);
CHECK(rectangle.height == 4); STATIC_CHECK(rectangle.height == 4);
} }
SUBCASE("Conversion constructor") SECTION("Conversion constructor")
{ {
const sf::FloatRect sourceRectangle({1.0f, 2.0f}, {3.0f, 4.0f}); constexpr sf::FloatRect sourceRectangle({1.0f, 2.0f}, {3.0f, 4.0f});
const sf::IntRect rectangle(sourceRectangle); constexpr sf::IntRect rectangle(sourceRectangle);
CHECK(rectangle.left == static_cast<int>(sourceRectangle.left)); STATIC_CHECK(rectangle.left == static_cast<int>(sourceRectangle.left));
CHECK(rectangle.top == static_cast<int>(sourceRectangle.top)); STATIC_CHECK(rectangle.top == static_cast<int>(sourceRectangle.top));
CHECK(rectangle.width == static_cast<int>(sourceRectangle.width)); STATIC_CHECK(rectangle.width == static_cast<int>(sourceRectangle.width));
CHECK(rectangle.height == static_cast<int>(sourceRectangle.height)); STATIC_CHECK(rectangle.height == static_cast<int>(sourceRectangle.height));
} }
} }
SUBCASE("contains(Vector2)") SECTION("contains(Vector2)")
{ {
const sf::IntRect rectangle({0, 0}, {10, 10}); constexpr sf::IntRect rectangle({0, 0}, {10, 10});
CHECK(rectangle.contains(sf::Vector2i(0, 0)) == true); STATIC_CHECK(rectangle.contains(sf::Vector2i(0, 0)) == true);
CHECK(rectangle.contains(sf::Vector2i(9, 0)) == true); STATIC_CHECK(rectangle.contains(sf::Vector2i(9, 0)) == true);
CHECK(rectangle.contains(sf::Vector2i(0, 9)) == true); STATIC_CHECK(rectangle.contains(sf::Vector2i(0, 9)) == true);
CHECK(rectangle.contains(sf::Vector2i(9, 9)) == true); STATIC_CHECK(rectangle.contains(sf::Vector2i(9, 9)) == true);
CHECK(rectangle.contains(sf::Vector2i(9, 10)) == false); STATIC_CHECK(rectangle.contains(sf::Vector2i(9, 10)) == false);
CHECK(rectangle.contains(sf::Vector2i(10, 9)) == false); STATIC_CHECK(rectangle.contains(sf::Vector2i(10, 9)) == false);
CHECK(rectangle.contains(sf::Vector2i(10, 10)) == false); STATIC_CHECK(rectangle.contains(sf::Vector2i(10, 10)) == false);
CHECK(rectangle.contains(sf::Vector2i(15, 15)) == false); STATIC_CHECK(rectangle.contains(sf::Vector2i(15, 15)) == false);
} }
SUBCASE("findIntersection()") SECTION("findIntersection()")
{ {
const sf::IntRect rectangle({0, 0}, {10, 10}); constexpr sf::IntRect rectangle({0, 0}, {10, 10});
const sf::IntRect intersectingRectangle({5, 5}, {10, 10}); constexpr sf::IntRect intersectingRectangle({5, 5}, {10, 10});
const auto intersectionResult = rectangle.findIntersection(intersectingRectangle); constexpr auto intersectionResult = rectangle.findIntersection(intersectingRectangle);
REQUIRE(intersectionResult.has_value()); STATIC_REQUIRE(intersectionResult.has_value());
CHECK(intersectionResult->top == 5); STATIC_CHECK(intersectionResult->top == 5);
CHECK(intersectionResult->left == 5); STATIC_CHECK(intersectionResult->left == 5);
CHECK(intersectionResult->width == 5); STATIC_CHECK(intersectionResult->width == 5);
CHECK(intersectionResult->height == 5); STATIC_CHECK(intersectionResult->height == 5);
const sf::IntRect nonIntersectingRectangle({-5, -5}, {5, 5}); constexpr sf::IntRect nonIntersectingRectangle({-5, -5}, {5, 5});
CHECK_FALSE(rectangle.findIntersection(nonIntersectingRectangle).has_value()); STATIC_CHECK_FALSE(rectangle.findIntersection(nonIntersectingRectangle).has_value());
} }
SUBCASE("getPosition()") SECTION("getPosition()")
{ {
CHECK(sf::IntRect({}, {}).getPosition() == sf::Vector2i()); STATIC_CHECK(sf::IntRect({}, {}).getPosition() == sf::Vector2i());
CHECK(sf::IntRect({1, 2}, {3, 4}).getPosition() == sf::Vector2i(1, 2)); STATIC_CHECK(sf::IntRect({1, 2}, {3, 4}).getPosition() == sf::Vector2i(1, 2));
} }
SUBCASE("getSize()") SECTION("getSize()")
{ {
CHECK(sf::IntRect({}, {}).getSize() == sf::Vector2i()); STATIC_CHECK(sf::IntRect({}, {}).getSize() == sf::Vector2i());
CHECK(sf::IntRect({1, 2}, {3, 4}).getSize() == sf::Vector2i(3, 4)); STATIC_CHECK(sf::IntRect({1, 2}, {3, 4}).getSize() == sf::Vector2i(3, 4));
} }
SUBCASE("Operators") SECTION("Operators")
{ {
SUBCASE("operator==") SECTION("operator==")
{ {
CHECK(sf::IntRect() == sf::IntRect()); STATIC_CHECK(sf::IntRect() == sf::IntRect());
CHECK(sf::IntRect({1, 3}, {2, 5}) == sf::IntRect({1, 3}, {2, 5})); STATIC_CHECK(sf::IntRect({1, 3}, {2, 5}) == sf::IntRect({1, 3}, {2, 5}));
CHECK_FALSE(sf::IntRect({1, 0}, {0, 0}) == sf::IntRect({0, 0}, {0, 0})); STATIC_CHECK_FALSE(sf::IntRect({1, 0}, {0, 0}) == sf::IntRect({0, 0}, {0, 0}));
CHECK_FALSE(sf::IntRect({0, 1}, {0, 0}) == sf::IntRect({0, 0}, {0, 0})); STATIC_CHECK_FALSE(sf::IntRect({0, 1}, {0, 0}) == sf::IntRect({0, 0}, {0, 0}));
CHECK_FALSE(sf::IntRect({0, 0}, {1, 0}) == sf::IntRect({0, 0}, {0, 0})); STATIC_CHECK_FALSE(sf::IntRect({0, 0}, {1, 0}) == sf::IntRect({0, 0}, {0, 0}));
CHECK_FALSE(sf::IntRect({0, 0}, {0, 1}) == sf::IntRect({0, 0}, {0, 0})); STATIC_CHECK_FALSE(sf::IntRect({0, 0}, {0, 1}) == sf::IntRect({0, 0}, {0, 0}));
} }
SUBCASE("operator!=") SECTION("operator!=")
{ {
CHECK(sf::IntRect({1, 0}, {0, 0}) != sf::IntRect({0, 0}, {0, 0})); STATIC_CHECK(sf::IntRect({1, 0}, {0, 0}) != sf::IntRect({0, 0}, {0, 0}));
CHECK(sf::IntRect({0, 1}, {0, 0}) != sf::IntRect({0, 0}, {0, 0})); STATIC_CHECK(sf::IntRect({0, 1}, {0, 0}) != sf::IntRect({0, 0}, {0, 0}));
CHECK(sf::IntRect({0, 0}, {1, 0}) != sf::IntRect({0, 0}, {0, 0})); STATIC_CHECK(sf::IntRect({0, 0}, {1, 0}) != sf::IntRect({0, 0}, {0, 0}));
CHECK(sf::IntRect({0, 0}, {0, 1}) != sf::IntRect({0, 0}, {0, 0})); STATIC_CHECK(sf::IntRect({0, 0}, {0, 1}) != sf::IntRect({0, 0}, {0, 0}));
CHECK_FALSE(sf::IntRect() != sf::IntRect()); STATIC_CHECK_FALSE(sf::IntRect() != sf::IntRect());
CHECK_FALSE(sf::IntRect({1, 3}, {2, 5}) != sf::IntRect({1, 3}, {2, 5})); STATIC_CHECK_FALSE(sf::IntRect({1, 3}, {2, 5}) != sf::IntRect({1, 3}, {2, 5}));
} }
} }
} }

21
test/Graphics/RectangleShape.test.cpp
View File

@ -1,18 +1,21 @@
#include <SFML/Graphics/RectangleShape.hpp> #include <SFML/Graphics/RectangleShape.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <SystemUtil.hpp> #include <SystemUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::RectangleShape>);
static_assert(std::is_copy_assignable_v<sf::RectangleShape>);
static_assert(std::is_nothrow_move_constructible_v<sf::RectangleShape>);
static_assert(std::is_nothrow_move_assignable_v<sf::RectangleShape>);
TEST_CASE("[Graphics] sf::RectangleShape") TEST_CASE("[Graphics] sf::RectangleShape")
{ {
SUBCASE("Default constructor") SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::RectangleShape>);
STATIC_CHECK(std::is_copy_assignable_v<sf::RectangleShape>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::RectangleShape>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::RectangleShape>);
}
SECTION("Default constructor")
{ {
const sf::RectangleShape rectangle; const sf::RectangleShape rectangle;
CHECK(rectangle.getSize() == sf::Vector2f(0, 0)); CHECK(rectangle.getSize() == sf::Vector2f(0, 0));
@ -23,7 +26,7 @@ TEST_CASE("[Graphics] sf::RectangleShape")
CHECK(rectangle.getPoint(3) == sf::Vector2f(0, 0)); CHECK(rectangle.getPoint(3) == sf::Vector2f(0, 0));
} }
SUBCASE("Size constructor") SECTION("Size constructor")
{ {
const sf::RectangleShape rectangle({9, 8}); const sf::RectangleShape rectangle({9, 8});
CHECK(rectangle.getSize() == sf::Vector2f(9, 8)); CHECK(rectangle.getSize() == sf::Vector2f(9, 8));
@ -34,7 +37,7 @@ TEST_CASE("[Graphics] sf::RectangleShape")
CHECK(rectangle.getPoint(3) == sf::Vector2f(0, 8)); CHECK(rectangle.getPoint(3) == sf::Vector2f(0, 8));
} }
SUBCASE("Set size") SECTION("Set size")
{ {
sf::RectangleShape rectangle({7, 6}); sf::RectangleShape rectangle({7, 6});
rectangle.setSize({5, 4}); rectangle.setSize({5, 4});

31
test/Graphics/RenderStates.test.cpp
View File

@ -1,20 +1,23 @@
#include <SFML/Graphics/RenderStates.hpp> #include <SFML/Graphics/RenderStates.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::RenderStates>);
static_assert(std::is_copy_assignable_v<sf::RenderStates>);
static_assert(std::is_nothrow_move_constructible_v<sf::RenderStates>);
static_assert(std::is_nothrow_move_assignable_v<sf::RenderStates>);
TEST_CASE("[Graphics] sf::RenderStates") TEST_CASE("[Graphics] sf::RenderStates")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::RenderStates>);
STATIC_CHECK(std::is_copy_assignable_v<sf::RenderStates>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::RenderStates>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::RenderStates>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::RenderStates renderStates; const sf::RenderStates renderStates;
CHECK(renderStates.blendMode == sf::BlendMode()); CHECK(renderStates.blendMode == sf::BlendMode());
@ -23,7 +26,7 @@ TEST_CASE("[Graphics] sf::RenderStates")
CHECK(renderStates.shader == nullptr); CHECK(renderStates.shader == nullptr);
} }
SUBCASE("BlendMode constructor") SECTION("BlendMode constructor")
{ {
const sf::BlendMode blendMode(sf::BlendMode::Zero, const sf::BlendMode blendMode(sf::BlendMode::Zero,
sf::BlendMode::SrcColor, sf::BlendMode::SrcColor,
@ -38,7 +41,7 @@ TEST_CASE("[Graphics] sf::RenderStates")
CHECK(renderStates.shader == nullptr); CHECK(renderStates.shader == nullptr);
} }
SUBCASE("Transform constructor") SECTION("Transform constructor")
{ {
const sf::Transform transform(10, 9, 8, 7, 6, 5, 4, 3, 2); const sf::Transform transform(10, 9, 8, 7, 6, 5, 4, 3, 2);
const sf::RenderStates renderStates(transform); const sf::RenderStates renderStates(transform);
@ -48,7 +51,7 @@ TEST_CASE("[Graphics] sf::RenderStates")
CHECK(renderStates.shader == nullptr); CHECK(renderStates.shader == nullptr);
} }
SUBCASE("Texture constructor") SECTION("Texture constructor")
{ {
const sf::Texture* texture = nullptr; const sf::Texture* texture = nullptr;
const sf::RenderStates renderStates(texture); const sf::RenderStates renderStates(texture);
@ -58,7 +61,7 @@ TEST_CASE("[Graphics] sf::RenderStates")
CHECK(renderStates.shader == nullptr); CHECK(renderStates.shader == nullptr);
} }
SUBCASE("Shader constructor") SECTION("Shader constructor")
{ {
const sf::Shader* shader = nullptr; const sf::Shader* shader = nullptr;
const sf::RenderStates renderStates(shader); const sf::RenderStates renderStates(shader);
@ -68,7 +71,7 @@ TEST_CASE("[Graphics] sf::RenderStates")
CHECK(renderStates.shader == shader); CHECK(renderStates.shader == shader);
} }
SUBCASE("Verbose constructor") SECTION("Verbose constructor")
{ {
const sf::BlendMode blendMode(sf::BlendMode::One, const sf::BlendMode blendMode(sf::BlendMode::One,
sf::BlendMode::SrcColor, sf::BlendMode::SrcColor,
@ -85,7 +88,7 @@ TEST_CASE("[Graphics] sf::RenderStates")
} }
} }
SUBCASE("Default constant") SECTION("Default constant")
{ {
CHECK(sf::RenderStates::Default.blendMode == sf::BlendMode()); CHECK(sf::RenderStates::Default.blendMode == sf::BlendMode());
CHECK(sf::RenderStates::Default.transform == sf::Transform()); CHECK(sf::RenderStates::Default.transform == sf::Transform());

21
test/Graphics/RenderWindow.test.cpp
View File

@ -8,19 +8,22 @@
#include <SFML/System/String.hpp> #include <SFML/System/String.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(!std::is_copy_constructible_v<sf::RenderWindow>); TEST_CASE("[Graphics] sf::RenderWindow", runDisplayTests())
static_assert(!std::is_copy_assignable_v<sf::RenderWindow>);
static_assert(!std::is_nothrow_move_constructible_v<sf::RenderWindow>);
static_assert(!std::is_nothrow_move_assignable_v<sf::RenderWindow>);
TEST_CASE("[Graphics] sf::RenderWindow" * doctest::skip(skipDisplayTests))
{ {
SUBCASE("Construction") SECTION("Type traits")
{
STATIC_CHECK(!std::is_copy_constructible_v<sf::RenderWindow>);
STATIC_CHECK(!std::is_copy_assignable_v<sf::RenderWindow>);
STATIC_CHECK(!std::is_nothrow_move_constructible_v<sf::RenderWindow>);
STATIC_CHECK(!std::is_nothrow_move_assignable_v<sf::RenderWindow>);
}
SECTION("Construction")
{ {
const sf::RenderWindow window(sf::VideoMode(sf::Vector2u(256, 256), 24), const sf::RenderWindow window(sf::VideoMode(sf::Vector2u(256, 256), 24),
"Window Title", "Window Title",
@ -29,7 +32,7 @@ TEST_CASE("[Graphics] sf::RenderWindow" * doctest::skip(skipDisplayTests))
CHECK(window.getSize() == sf::Vector2u(256, 256)); CHECK(window.getSize() == sf::Vector2u(256, 256));
} }
SUBCASE("Clear") SECTION("Clear")
{ {
sf::RenderWindow window(sf::VideoMode(sf::Vector2u(256, 256), 24), sf::RenderWindow window(sf::VideoMode(sf::Vector2u(256, 256), 24),
"Window Title", "Window Title",

45
test/Graphics/Shader.test.cpp
View File

@ -1,14 +1,9 @@
#include <SFML/Graphics/Shader.hpp> #include <SFML/Graphics/Shader.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <type_traits> #include <type_traits>
static_assert(!std::is_copy_constructible_v<sf::Shader>);
static_assert(!std::is_copy_assignable_v<sf::Shader>);
static_assert(std::is_nothrow_move_constructible_v<sf::Shader>);
static_assert(std::is_nothrow_move_assignable_v<sf::Shader>);
namespace namespace
{ {
constexpr auto vertexSource = R"( constexpr auto vertexSource = R"(
@ -117,17 +112,37 @@ constexpr bool skipShaderDummyTest = true;
constexpr bool skipShaderFullTest = true; constexpr bool skipShaderFullTest = true;
#endif #endif
std::string skipShaderDummyTests()
{
if constexpr (skipShaderDummyTest)
// https://github.com/catchorg/Catch2/blob/devel/docs/test-cases-and-sections.md#special-tags
// This tag tells Catch2 to not run a given TEST_CASE
return "[.shaderDummy]";
else
return "";
}
std::string skipShaderFullTests()
{
if constexpr (skipShaderFullTest)
// https://github.com/catchorg/Catch2/blob/devel/docs/test-cases-and-sections.md#special-tags
// This tag tells Catch2 to not run a given TEST_CASE
return "[.shaderFull]";
else
return "";
}
} // namespace } // namespace
TEST_CASE("[Graphics] sf::Shader (Dummy Implementation)" * doctest::skip(skipShaderDummyTest)) TEST_CASE("[Graphics] sf::Shader (Dummy Implementation)", skipShaderDummyTests())
{ {
SUBCASE("Available") SECTION("Available")
{ {
CHECK_FALSE(sf::Shader::isAvailable()); CHECK_FALSE(sf::Shader::isAvailable());
CHECK_FALSE(sf::Shader::isGeometryAvailable()); CHECK_FALSE(sf::Shader::isGeometryAvailable());
} }
SUBCASE("Load") SECTION("Load")
{ {
sf::Shader shader; sf::Shader shader;
CHECK_FALSE(shader.loadFromMemory(vertexSource, sf::Shader::Type::Vertex)); CHECK_FALSE(shader.loadFromMemory(vertexSource, sf::Shader::Type::Vertex));
@ -138,12 +153,20 @@ TEST_CASE("[Graphics] sf::Shader (Dummy Implementation)" * doctest::skip(skipSha
} }
} }
TEST_CASE("[Graphics] sf::Shader" * doctest::skip(skipShaderFullTest)) TEST_CASE("[Graphics] sf::Shader", skipShaderFullTests())
{ {
SECTION("Type traits")
{
STATIC_CHECK(!std::is_copy_constructible_v<sf::Shader>);
STATIC_CHECK(!std::is_copy_assignable_v<sf::Shader>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Shader>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Shader>);
}
if (!sf::Shader::isAvailable()) if (!sf::Shader::isAvailable())
return; return;
SUBCASE("Load") SECTION("Load")
{ {
sf::Shader shader; sf::Shader shader;
CHECK(shader.loadFromMemory(vertexSource, sf::Shader::Type::Vertex)); CHECK(shader.loadFromMemory(vertexSource, sf::Shader::Type::Vertex));

33
test/Graphics/Shape.test.cpp
View File

@ -1,17 +1,10 @@
#include <SFML/Graphics/Shape.hpp> #include <SFML/Graphics/Shape.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(!std::is_constructible_v<sf::Shape>);
static_assert(!std::is_copy_constructible_v<sf::Shape>);
static_assert(std::is_copy_assignable_v<sf::Shape>);
static_assert(!std::is_move_constructible_v<sf::Shape>);
static_assert(std::is_nothrow_move_assignable_v<sf::Shape>);
static_assert(std::has_virtual_destructor_v<sf::Shape>);
class TriangleShape : public sf::Shape class TriangleShape : public sf::Shape
{ {
public: public:
@ -45,7 +38,17 @@ private:
TEST_CASE("[Graphics] sf::Shape") TEST_CASE("[Graphics] sf::Shape")
{ {
SUBCASE("Default constructor") SECTION("Type traits")
{
STATIC_CHECK(!std::is_constructible_v<sf::Shape>);
STATIC_CHECK(!std::is_copy_constructible_v<sf::Shape>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Shape>);
STATIC_CHECK(!std::is_move_constructible_v<sf::Shape>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Shape>);
STATIC_CHECK(std::has_virtual_destructor_v<sf::Shape>);
}
SECTION("Default constructor")
{ {
const TriangleShape triangleShape({0, 0}); const TriangleShape triangleShape({0, 0});
CHECK(triangleShape.getTexture() == nullptr); CHECK(triangleShape.getTexture() == nullptr);
@ -57,35 +60,35 @@ TEST_CASE("[Graphics] sf::Shape")
CHECK(triangleShape.getGlobalBounds() == sf::FloatRect()); CHECK(triangleShape.getGlobalBounds() == sf::FloatRect());
} }
SUBCASE("Set/get texture rect") SECTION("Set/get texture rect")
{ {
TriangleShape triangleShape({}); TriangleShape triangleShape({});
triangleShape.setTextureRect({{4, 5}, {6, 7}}); triangleShape.setTextureRect({{4, 5}, {6, 7}});
CHECK(triangleShape.getTextureRect() == sf::IntRect({4, 5}, {6, 7})); CHECK(triangleShape.getTextureRect() == sf::IntRect({4, 5}, {6, 7}));
} }
SUBCASE("Set/get fill color") SECTION("Set/get fill color")
{ {
TriangleShape triangleShape({}); TriangleShape triangleShape({});
triangleShape.setFillColor(sf::Color::Cyan); triangleShape.setFillColor(sf::Color::Cyan);
CHECK(triangleShape.getFillColor() == sf::Color::Cyan); CHECK(triangleShape.getFillColor() == sf::Color::Cyan);
} }
SUBCASE("Set/get outline color") SECTION("Set/get outline color")
{ {
TriangleShape triangleShape({}); TriangleShape triangleShape({});
triangleShape.setOutlineColor(sf::Color::Magenta); triangleShape.setOutlineColor(sf::Color::Magenta);
CHECK(triangleShape.getOutlineColor() == sf::Color::Magenta); CHECK(triangleShape.getOutlineColor() == sf::Color::Magenta);
} }
SUBCASE("Set/get outline thickness") SECTION("Set/get outline thickness")
{ {
TriangleShape triangleShape({}); TriangleShape triangleShape({});
triangleShape.setOutlineThickness(3.14f); triangleShape.setOutlineThickness(3.14f);
CHECK(triangleShape.getOutlineThickness() == 3.14f); CHECK(triangleShape.getOutlineThickness() == 3.14f);
} }
SUBCASE("Virtual functions: getPoint, getPointCount") SECTION("Virtual functions: getPoint, getPointCount")
{ {
const TriangleShape triangleShape({2, 2}); const TriangleShape triangleShape({2, 2});
CHECK(triangleShape.getPointCount() == 3); CHECK(triangleShape.getPointCount() == 3);
@ -94,7 +97,7 @@ TEST_CASE("[Graphics] sf::Shape")
CHECK(triangleShape.getPoint(2) == sf::Vector2f(2, 2)); CHECK(triangleShape.getPoint(2) == sf::Vector2f(2, 2));
} }
SUBCASE("Get bounds") SECTION("Get bounds")
{ {
TriangleShape triangleShape({2, 3}); TriangleShape triangleShape({2, 3});
CHECK(triangleShape.getLocalBounds() == sf::FloatRect({0, 0}, {2, 3})); CHECK(triangleShape.getLocalBounds() == sf::FloatRect({0, 0}, {2, 3}));

61
test/Graphics/Texture.test.cpp
View File

@ -3,20 +3,25 @@
// Other 1st party headers // Other 1st party headers
#include <SFML/Graphics/Image.hpp> #include <SFML/Graphics/Image.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::Texture>); TEST_CASE("[Graphics] sf::Texture", runDisplayTests())
static_assert(std::is_copy_assignable_v<sf::Texture>);
static_assert(std::is_nothrow_move_constructible_v<sf::Texture>);
static_assert(std::is_nothrow_move_assignable_v<sf::Texture>);
static_assert(std::is_nothrow_swappable_v<sf::Texture>);
TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
{ {
SUBCASE("Construction") SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::Texture>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Texture>);
STATIC_CHECK(std::is_move_constructible_v<sf::Texture>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Texture>);
STATIC_CHECK(std::is_move_assignable_v<sf::Texture>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Texture>);
STATIC_CHECK(std::is_nothrow_swappable_v<sf::Texture>);
}
SECTION("Construction")
{ {
const sf::Texture texture; const sf::Texture texture;
CHECK(texture.getSize() == sf::Vector2u()); CHECK(texture.getSize() == sf::Vector2u());
@ -26,32 +31,32 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
CHECK(texture.getNativeHandle() == 0); CHECK(texture.getNativeHandle() == 0);
} }
SUBCASE("create()") SECTION("create()")
{ {
sf::Texture texture; sf::Texture texture;
SUBCASE("At least one zero dimension") SECTION("At least one zero dimension")
{ {
CHECK(!texture.create({})); CHECK(!texture.create({}));
CHECK(!texture.create({0, 1})); CHECK(!texture.create({0, 1}));
CHECK(!texture.create({1, 0})); CHECK(!texture.create({1, 0}));
} }
SUBCASE("Valid size") SECTION("Valid size")
{ {
CHECK(texture.create({100, 100})); CHECK(texture.create({100, 100}));
CHECK(texture.getSize() == sf::Vector2u(100, 100)); CHECK(texture.getSize() == sf::Vector2u(100, 100));
CHECK(texture.getNativeHandle() != 0); CHECK(texture.getNativeHandle() != 0);
} }
SUBCASE("Too large") SECTION("Too large")
{ {
CHECK(!texture.create({100'000, 100'000})); CHECK(!texture.create({100'000, 100'000}));
CHECK(!texture.create({1'000'000, 1'000'000})); CHECK(!texture.create({1'000'000, 1'000'000}));
} }
} }
SUBCASE("Copy semantics") SECTION("Copy semantics")
{ {
constexpr std::uint8_t red[] = {0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF}; constexpr std::uint8_t red[] = {0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF};
@ -59,14 +64,14 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
REQUIRE(texture.create(sf::Vector2u(1, 2))); REQUIRE(texture.create(sf::Vector2u(1, 2)));
texture.update(red); texture.update(red);
SUBCASE("Construction") SECTION("Construction")
{ {
const sf::Texture textureCopy(texture); // NOLINT(performance-unnecessary-copy-initialization) const sf::Texture textureCopy(texture); // NOLINT(performance-unnecessary-copy-initialization)
REQUIRE(textureCopy.getSize() == sf::Vector2u(1, 2)); REQUIRE(textureCopy.getSize() == sf::Vector2u(1, 2));
CHECK(textureCopy.copyToImage().getPixel(sf::Vector2u(0, 1)) == sf::Color::Red); CHECK(textureCopy.copyToImage().getPixel(sf::Vector2u(0, 1)) == sf::Color::Red);
} }
SUBCASE("Assignment") SECTION("Assignment")
{ {
sf::Texture textureCopy; sf::Texture textureCopy;
textureCopy = texture; textureCopy = texture;
@ -75,21 +80,21 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
} }
} }
SUBCASE("update()") SECTION("update()")
{ {
constexpr std::uint8_t yellow[] = {0xFF, 0xFF, 0x00, 0xFF}; constexpr std::uint8_t yellow[] = {0xFF, 0xFF, 0x00, 0xFF};
constexpr std::uint8_t cyan[] = {0x00, 0xFF, 0xFF, 0xFF}; constexpr std::uint8_t cyan[] = {0x00, 0xFF, 0xFF, 0xFF};
sf::Texture texture; sf::Texture texture;
SUBCASE("Pixels") SECTION("Pixels")
{ {
REQUIRE(texture.create(sf::Vector2u(1, 1))); REQUIRE(texture.create(sf::Vector2u(1, 1)));
texture.update(yellow); texture.update(yellow);
CHECK(texture.copyToImage().getPixel(sf::Vector2u(0, 0)) == sf::Color::Yellow); CHECK(texture.copyToImage().getPixel(sf::Vector2u(0, 0)) == sf::Color::Yellow);
} }
SUBCASE("Pixels, size and destination") SECTION("Pixels, size and destination")
{ {
REQUIRE(texture.create(sf::Vector2u(2, 1))); REQUIRE(texture.create(sf::Vector2u(2, 1)));
texture.update(yellow, sf::Vector2u(1, 1), sf::Vector2u(0, 0)); texture.update(yellow, sf::Vector2u(1, 1), sf::Vector2u(0, 0));
@ -98,7 +103,7 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
CHECK(texture.copyToImage().getPixel(sf::Vector2u(1, 0)) == sf::Color::Cyan); CHECK(texture.copyToImage().getPixel(sf::Vector2u(1, 0)) == sf::Color::Cyan);
} }
SUBCASE("Another texture") SECTION("Another texture")
{ {
sf::Texture otherTexture; sf::Texture otherTexture;
REQUIRE(otherTexture.create(sf::Vector2u(1, 1))); REQUIRE(otherTexture.create(sf::Vector2u(1, 1)));
@ -108,7 +113,7 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
CHECK(texture.copyToImage().getPixel(sf::Vector2u(0, 0)) == sf::Color::Cyan); CHECK(texture.copyToImage().getPixel(sf::Vector2u(0, 0)) == sf::Color::Cyan);
} }
SUBCASE("Another texture and destination") SECTION("Another texture and destination")
{ {
REQUIRE(texture.create(sf::Vector2u(2, 1))); REQUIRE(texture.create(sf::Vector2u(2, 1)));
sf::Texture otherTexture1; sf::Texture otherTexture1;
@ -123,7 +128,7 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
CHECK(texture.copyToImage().getPixel(sf::Vector2u(1, 0)) == sf::Color::Yellow); CHECK(texture.copyToImage().getPixel(sf::Vector2u(1, 0)) == sf::Color::Yellow);
} }
SUBCASE("Image") SECTION("Image")
{ {
REQUIRE(texture.create(sf::Vector2u(16, 32))); REQUIRE(texture.create(sf::Vector2u(16, 32)));
sf::Image image; sf::Image image;
@ -132,7 +137,7 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
CHECK(texture.copyToImage().getPixel(sf::Vector2u(7, 15)) == sf::Color::Red); CHECK(texture.copyToImage().getPixel(sf::Vector2u(7, 15)) == sf::Color::Red);
} }
SUBCASE("Image and destination") SECTION("Image and destination")
{ {
REQUIRE(texture.create(sf::Vector2u(16, 32))); REQUIRE(texture.create(sf::Vector2u(16, 32)));
sf::Image image1; sf::Image image1;
@ -147,7 +152,7 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
} }
} }
SUBCASE("Set/get smooth") SECTION("Set/get smooth")
{ {
sf::Texture texture; sf::Texture texture;
CHECK(!texture.isSmooth()); CHECK(!texture.isSmooth());
@ -157,7 +162,7 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
CHECK(!texture.isSmooth()); CHECK(!texture.isSmooth());
} }
SUBCASE("Set/get srgb") SECTION("Set/get srgb")
{ {
sf::Texture texture; sf::Texture texture;
CHECK(!texture.isSrgb()); CHECK(!texture.isSrgb());
@ -167,7 +172,7 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
CHECK(!texture.isSrgb()); CHECK(!texture.isSrgb());
} }
SUBCASE("Set/get repeated") SECTION("Set/get repeated")
{ {
sf::Texture texture; sf::Texture texture;
CHECK(!texture.isRepeated()); CHECK(!texture.isRepeated());
@ -177,7 +182,7 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
CHECK(!texture.isRepeated()); CHECK(!texture.isRepeated());
} }
SUBCASE("swap()") SECTION("swap()")
{ {
constexpr std::uint8_t blue[] = {0x00, 0x00, 0xFF, 0xFF}; constexpr std::uint8_t blue[] = {0x00, 0x00, 0xFF, 0xFF};
constexpr std::uint8_t green[] = {0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF}; constexpr std::uint8_t green[] = {0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF};
@ -212,7 +217,7 @@ TEST_CASE("[Graphics] sf::Texture" * doctest::skip(skipDisplayTests))
CHECK(image2.getPixel(sf::Vector2u(0, 0)) == sf::Color::Blue); CHECK(image2.getPixel(sf::Vector2u(0, 0)) == sf::Color::Blue);
} }
SUBCASE("Get Maximum Size") SECTION("Get Maximum Size")
{ {
CHECK(sf::Texture::getMaximumSize() > 0); CHECK(sf::Texture::getMaximumSize() > 0);
} }

235
test/Graphics/Transform.test.cpp
View File

@ -2,106 +2,91 @@
#include <SFML/System/Angle.hpp> #include <SFML/System/Angle.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <sstream>
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
static_assert(std::is_copy_constructible_v<sf::Transform>);
static_assert(std::is_copy_assignable_v<sf::Transform>);
static_assert(std::is_nothrow_move_constructible_v<sf::Transform>);
static_assert(std::is_nothrow_move_assignable_v<sf::Transform>);
// Specialize StringMaker for std::vector<float>
// https://github.com/doctest/doctest/blob/master/doc/markdown/stringification.md#docteststringmakert-specialisation
namespace doctest
{
template <>
struct StringMaker<std::vector<float>>
{
static String convert(const std::vector<float>& vector)
{
assert(!vector.empty());
doctest::String out = "{ ";
for (std::size_t i = 0; i + 1 < vector.size(); ++i)
out += toString(vector[i]) + ", ";
out += toString(vector.back()) + " }";
return out;
}
};
} // namespace doctest
TEST_CASE("[Graphics] sf::Transform") TEST_CASE("[Graphics] sf::Transform")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::Transform>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Transform>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Transform>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Transform>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
CHECK(sf::Transform() == sf::Transform::Identity); STATIC_CHECK(sf::Transform() == sf::Transform::Identity);
} }
SUBCASE("3x3 matrix constructor") SECTION("3x3 matrix constructor")
{ {
const sf::Transform transform(10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f); constexpr sf::Transform transform(10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f);
const std::vector<float> matrix(transform.getMatrix(), transform.getMatrix() + 16); const std::vector matrix(transform.getMatrix(), transform.getMatrix() + 16);
CHECK( CHECK(matrix ==
matrix == std::vector{10.0f, 13.0f, 0.0f, 16.0f, 11.0f, 14.0f, 0.0f, 17.0f, 0.0f, 0.0f, 1.0f, 0.0f, 12.0f, 15.0f, 0.0f, 18.0f});
std::vector<float>{10.0f, 13.0f, 0.0f, 16.0f, 11.0f, 14.0f, 0.0f, 17.0f, 0.0f, 0.0f, 1.0f, 0.0f, 12.0f, 15.0f, 0.0f, 18.0f});
} }
} }
SUBCASE("Identity matrix") SECTION("Identity matrix")
{ {
const std::vector<float> matrix(sf::Transform::Identity.getMatrix(), sf::Transform::Identity.getMatrix() + 16); const std::vector matrix(sf::Transform::Identity.getMatrix(), sf::Transform::Identity.getMatrix() + 16);
CHECK(matrix == CHECK(matrix ==
std::vector<float>{1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}); std::vector{1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f});
} }
SUBCASE("getInverse()") SECTION("getInverse()")
{ {
CHECK(sf::Transform::Identity.getInverse() == sf::Transform::Identity); STATIC_CHECK(sf::Transform::Identity.getInverse() == sf::Transform::Identity);
CHECK(sf::Transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f).getInverse() == sf::Transform::Identity); STATIC_CHECK(sf::Transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f).getInverse() ==
CHECK(sf::Transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f).getInverse() == sf::Transform::Identity);
sf::Transform(0.375f, -0.5f, 0.875f, -1.0f, 1.0f, -1.0f, 0.875f, -0.5f, 0.375f)); STATIC_CHECK(sf::Transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f).getInverse() ==
sf::Transform(0.375f, -0.5f, 0.875f, -1.0f, 1.0f, -1.0f, 0.875f, -0.5f, 0.375f));
} }
SUBCASE("transformPoint()") SECTION("transformPoint()")
{ {
CHECK(sf::Transform::Identity.transformPoint({-10.0f, -10.0f}) == sf::Vector2f(-10.0f, -10.0f)); STATIC_CHECK(sf::Transform::Identity.transformPoint({-10.0f, -10.0f}) == sf::Vector2f(-10.0f, -10.0f));
CHECK(sf::Transform::Identity.transformPoint({-1.0f, -1.0f}) == sf::Vector2f(-1.0f, -1.0f)); STATIC_CHECK(sf::Transform::Identity.transformPoint({-1.0f, -1.0f}) == sf::Vector2f(-1.0f, -1.0f));
CHECK(sf::Transform::Identity.transformPoint({-1.0f, 0.0f}) == sf::Vector2f(-1.0f, 0.0f)); STATIC_CHECK(sf::Transform::Identity.transformPoint({-1.0f, 0.0f}) == sf::Vector2f(-1.0f, 0.0f));
CHECK(sf::Transform::Identity.transformPoint({0.0f, 0.0f}) == sf::Vector2f(0.0f, 0.0f)); STATIC_CHECK(sf::Transform::Identity.transformPoint({0.0f, 0.0f}) == sf::Vector2f(0.0f, 0.0f));
CHECK(sf::Transform::Identity.transformPoint({0.0f, 1.0f}) == sf::Vector2f(0.0f, 1.0f)); STATIC_CHECK(sf::Transform::Identity.transformPoint({0.0f, 1.0f}) == sf::Vector2f(0.0f, 1.0f));
CHECK(sf::Transform::Identity.transformPoint({1.0f, 1.0f}) == sf::Vector2f(1.0f, 1.0f)); STATIC_CHECK(sf::Transform::Identity.transformPoint({1.0f, 1.0f}) == sf::Vector2f(1.0f, 1.0f));
CHECK(sf::Transform::Identity.transformPoint({10.0f, 10.0f}) == sf::Vector2f(10.0f, 10.0f)); STATIC_CHECK(sf::Transform::Identity.transformPoint({10.0f, 10.0f}) == sf::Vector2f(10.0f, 10.0f));
const sf::Transform transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f); constexpr sf::Transform transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f);
CHECK(transform.transformPoint({-1.0f, -1.0f}) == sf::Vector2f(0.0f, -5.0f)); STATIC_CHECK(transform.transformPoint({-1.0f, -1.0f}) == sf::Vector2f(0.0f, -5.0f));
CHECK(transform.transformPoint({0.0f, 0.0f}) == sf::Vector2f(3.0f, 4.0f)); STATIC_CHECK(transform.transformPoint({0.0f, 0.0f}) == sf::Vector2f(3.0f, 4.0f));
CHECK(transform.transformPoint({1.0f, 1.0f}) == sf::Vector2f(6.0f, 13.0f)); STATIC_CHECK(transform.transformPoint({1.0f, 1.0f}) == sf::Vector2f(6.0f, 13.0f));
} }
SUBCASE("transformRect()") SECTION("transformRect()")
{ {
CHECK(sf::Transform::Identity.transformRect({{-200.0f, -200.0f}, {-100.0f, -100.0f}}) == STATIC_CHECK(sf::Transform::Identity.transformRect({{-200.0f, -200.0f}, {-100.0f, -100.0f}}) ==
sf::FloatRect({-300.0f, -300.0f}, {100.0f, 100.0f})); sf::FloatRect({-300.0f, -300.0f}, {100.0f, 100.0f}));
CHECK(sf::Transform::Identity.transformRect({{0.0f, 0.0f}, {0.0f, 0.0f}}) == STATIC_CHECK(sf::Transform::Identity.transformRect({{0.0f, 0.0f}, {0.0f, 0.0f}}) ==
sf::FloatRect({0.0f, 0.0f}, {0.0f, 0.0f})); sf::FloatRect({0.0f, 0.0f}, {0.0f, 0.0f}));
CHECK(sf::Transform::Identity.transformRect({{100.0f, 100.0f}, {200.0f, 200.0f}}) == STATIC_CHECK(sf::Transform::Identity.transformRect({{100.0f, 100.0f}, {200.0f, 200.0f}}) ==
sf::FloatRect({100.0f, 100.0f}, {200.0f, 200.0f})); sf::FloatRect({100.0f, 100.0f}, {200.0f, 200.0f}));
const sf::Transform transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f); constexpr sf::Transform transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f);
CHECK(transform.transformRect({{-100.0f, -100.0f}, {200.0f, 200.0f}}) == STATIC_CHECK(transform.transformRect({{-100.0f, -100.0f}, {200.0f, 200.0f}}) ==
sf::FloatRect({-297.0f, -896.0f}, {600.0f, 1800.0f})); sf::FloatRect({-297.0f, -896.0f}, {600.0f, 1800.0f}));
CHECK(transform.transformRect({{0.0f, 0.0f}, {0.0f, 0.0f}}) == sf::FloatRect({3.0f, 4.0f}, {0.0f, 0.0f})); STATIC_CHECK(transform.transformRect({{0.0f, 0.0f}, {0.0f, 0.0f}}) == sf::FloatRect({3.0f, 4.0f}, {0.0f, 0.0f}));
CHECK(transform.transformRect({{100.0f, 100.0f}, {200.0f, 200.0f}}) == STATIC_CHECK(transform.transformRect({{100.0f, 100.0f}, {200.0f, 200.0f}}) ==
sf::FloatRect({303.0f, 904.0f}, {600.0f, 1800.0f})); sf::FloatRect({303.0f, 904.0f}, {600.0f, 1800.0f}));
} }
SUBCASE("combine()") SECTION("combine()")
{ {
auto identity = sf::Transform::Identity; auto identity = sf::Transform::Identity;
CHECK(identity.combine(sf::Transform::Identity) == sf::Transform::Identity); CHECK(identity.combine(sf::Transform::Identity) == sf::Transform::Identity);
@ -115,23 +100,23 @@ TEST_CASE("[Graphics] sf::Transform")
sf::Transform(672.0f, 1216.0f, 914.0f, 1604.0f, 2842.0f, 2108.0f, 752.0f, 1288.0f, 942.0f)); sf::Transform(672.0f, 1216.0f, 914.0f, 1604.0f, 2842.0f, 2108.0f, 752.0f, 1288.0f, 942.0f));
} }
SUBCASE("translate()") SECTION("translate()")
{ {
sf::Transform transform(9, 8, 7, 6, 5, 4, 3, 2, 1); sf::Transform transform(9, 8, 7, 6, 5, 4, 3, 2, 1);
CHECK(transform.translate({10.0f, 20.0f}) == sf::Transform(9, 8, 257, 6, 5, 164, 3, 2, 71)); CHECK(transform.translate({10.0f, 20.0f}) == sf::Transform(9, 8, 257, 6, 5, 164, 3, 2, 71));
CHECK(transform.translate({10.0f, 20.0f}) == sf::Transform(9, 8, 507, 6, 5, 324, 3, 2, 141)); CHECK(transform.translate({10.0f, 20.0f}) == sf::Transform(9, 8, 507, 6, 5, 324, 3, 2, 141));
} }
SUBCASE("rotate()") SECTION("rotate()")
{ {
SUBCASE("Around origin") SECTION("Around origin")
{ {
sf::Transform transform; sf::Transform transform;
transform.rotate(sf::degrees(90)); transform.rotate(sf::degrees(90));
CHECK(transform == Approx(sf::Transform(0, -1, 0, 1, 0, 0, 0, 0, 1))); CHECK(transform == Approx(sf::Transform(0, -1, 0, 1, 0, 0, 0, 0, 1)));
} }
SUBCASE("Around custom point") SECTION("Around custom point")
{ {
sf::Transform transform; sf::Transform transform;
transform.rotate(sf::degrees(90), {1.0f, 0.0f}); transform.rotate(sf::degrees(90), {1.0f, 0.0f});
@ -139,9 +124,9 @@ TEST_CASE("[Graphics] sf::Transform")
} }
} }
SUBCASE("scale()") SECTION("scale()")
{ {
SUBCASE("About origin") SECTION("About origin")
{ {
sf::Transform transform(1, 2, 3, 4, 5, 4, 3, 2, 1); sf::Transform transform(1, 2, 3, 4, 5, 4, 3, 2, 1);
CHECK(transform.scale({2.0f, 4.0f}) == sf::Transform(2, 8, 3, 8, 20, 4, 6, 8, 1)); CHECK(transform.scale({2.0f, 4.0f}) == sf::Transform(2, 8, 3, 8, 20, 4, 6, 8, 1));
@ -149,7 +134,7 @@ TEST_CASE("[Graphics] sf::Transform")
CHECK(transform.scale({10.0f, 10.0f}) == sf::Transform(0, 0, 3, 0, 0, 4, 0, 0, 1)); CHECK(transform.scale({10.0f, 10.0f}) == sf::Transform(0, 0, 3, 0, 0, 4, 0, 0, 1));
} }
SUBCASE("About custom point") SECTION("About custom point")
{ {
sf::Transform transform(1, 2, 3, 4, 5, 4, 3, 2, 1); sf::Transform transform(1, 2, 3, 4, 5, 4, 3, 2, 1);
CHECK(transform.scale({1.0f, 2.0f}, {1.0f, 0.0f}) == sf::Transform(1, 4, 3, 4, 10, 4, 3, 4, 1)); CHECK(transform.scale({1.0f, 2.0f}, {1.0f, 0.0f}) == sf::Transform(1, 4, 3, 4, 10, 4, 3, 4, 1));
@ -157,22 +142,24 @@ TEST_CASE("[Graphics] sf::Transform")
} }
} }
SUBCASE("Operators") SECTION("Operators")
{ {
SUBCASE("operator*") SECTION("operator*")
{ {
CHECK(sf::Transform::Identity * sf::Transform::Identity == sf::Transform::Identity); STATIC_CHECK(sf::Transform::Identity * sf::Transform::Identity == sf::Transform::Identity);
CHECK(sf::Transform::Identity * sf::Transform::Identity * sf::Transform::Identity == sf::Transform::Identity); STATIC_CHECK(sf::Transform::Identity * sf::Transform::Identity * sf::Transform::Identity ==
sf::Transform::Identity);
const sf::Transform transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f); constexpr sf::Transform transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f);
CHECK(sf::Transform::Identity * transform == transform); STATIC_CHECK(sf::Transform::Identity * transform == transform);
CHECK(transform * sf::Transform::Identity == transform); STATIC_CHECK(transform * sf::Transform::Identity == transform);
CHECK(transform * transform == sf::Transform(18.0f, 18.0f, 14.0f, 36.0f, 41.0f, 36.0f, 14.0f, 18.0f, 18.0f)); STATIC_CHECK(transform * transform ==
CHECK(transform * sf::Transform(10.0f, 2.0f, 3.0f, 4.0f, 50.0f, 40.0f, 30.0f, 20.0f, 10.0f) == sf::Transform(18.0f, 18.0f, 14.0f, 36.0f, 41.0f, 36.0f, 14.0f, 18.0f, 18.0f));
sf::Transform(108.0f, 162.0f, 113.0f, 180.0f, 338.0f, 252.0f, 68.0f, 126.0f, 99.0f)); STATIC_CHECK(transform * sf::Transform(10.0f, 2.0f, 3.0f, 4.0f, 50.0f, 40.0f, 30.0f, 20.0f, 10.0f) ==
sf::Transform(108.0f, 162.0f, 113.0f, 180.0f, 338.0f, 252.0f, 68.0f, 126.0f, 99.0f));
} }
SUBCASE("operator*=") SECTION("operator*=")
{ {
sf::Transform transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f); sf::Transform transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f);
transform *= sf::Transform::Identity; transform *= sf::Transform::Identity;
@ -183,52 +170,54 @@ TEST_CASE("[Graphics] sf::Transform")
CHECK(transform == sf::Transform(672.0f, 1216.0f, 914.0f, 1604.0f, 2842.0f, 2108.0f, 752.0f, 1288.0f, 942.0f)); CHECK(transform == sf::Transform(672.0f, 1216.0f, 914.0f, 1604.0f, 2842.0f, 2108.0f, 752.0f, 1288.0f, 942.0f));
} }
SUBCASE("operator* with vector") SECTION("operator* with vector")
{ {
CHECK(sf::Transform::Identity * sf::Vector2f(-10.0f, -10.0f) == sf::Vector2f(-10.0f, -10.0f)); STATIC_CHECK(sf::Transform::Identity * sf::Vector2f(-10.0f, -10.0f) == sf::Vector2f(-10.0f, -10.0f));
CHECK(sf::Transform::Identity * sf::Vector2f(-1.0f, -1.0f) == sf::Vector2f(-1.0f, -1.0f)); STATIC_CHECK(sf::Transform::Identity * sf::Vector2f(-1.0f, -1.0f) == sf::Vector2f(-1.0f, -1.0f));
CHECK(sf::Transform::Identity * sf::Vector2f(-1.0f, 0.0f) == sf::Vector2f(-1.0f, 0.0f)); STATIC_CHECK(sf::Transform::Identity * sf::Vector2f(-1.0f, 0.0f) == sf::Vector2f(-1.0f, 0.0f));
CHECK(sf::Transform::Identity * sf::Vector2f(0.0f, 0.0f) == sf::Vector2f(0.0f, 0.0f)); STATIC_CHECK(sf::Transform::Identity * sf::Vector2f(0.0f, 0.0f) == sf::Vector2f(0.0f, 0.0f));
CHECK(sf::Transform::Identity * sf::Vector2f(0.0f, 1.0f) == sf::Vector2f(0.0f, 1.0f)); STATIC_CHECK(sf::Transform::Identity * sf::Vector2f(0.0f, 1.0f) == sf::Vector2f(0.0f, 1.0f));
CHECK(sf::Transform::Identity * sf::Vector2f(1.0f, 1.0f) == sf::Vector2f(1.0f, 1.0f)); STATIC_CHECK(sf::Transform::Identity * sf::Vector2f(1.0f, 1.0f) == sf::Vector2f(1.0f, 1.0f));
CHECK(sf::Transform::Identity * sf::Vector2f(10.0f, 10.0f) == sf::Vector2f(10.0f, 10.0f)); STATIC_CHECK(sf::Transform::Identity * sf::Vector2f(10.0f, 10.0f) == sf::Vector2f(10.0f, 10.0f));
const sf::Transform transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f); constexpr sf::Transform transform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f);
CHECK(transform * sf::Vector2f(-1.0f, -1.0f) == sf::Vector2f(0.0f, -5.0f)); STATIC_CHECK(transform * sf::Vector2f(-1.0f, -1.0f) == sf::Vector2f(0.0f, -5.0f));
CHECK(transform * sf::Vector2f(0.0f, 0.0f) == sf::Vector2f(3.0f, 4.0f)); STATIC_CHECK(transform * sf::Vector2f(0.0f, 0.0f) == sf::Vector2f(3.0f, 4.0f));
CHECK(transform * sf::Vector2f(1.0f, 1.0f) == sf::Vector2f(6.0f, 13.0f)); STATIC_CHECK(transform * sf::Vector2f(1.0f, 1.0f) == sf::Vector2f(6.0f, 13.0f));
} }
SUBCASE("operator==") SECTION("operator==")
{ {
CHECK(sf::Transform::Identity == sf::Transform::Identity); STATIC_CHECK(sf::Transform::Identity == sf::Transform::Identity);
CHECK(sf::Transform() == sf::Transform()); STATIC_CHECK(sf::Transform() == sf::Transform());
CHECK(sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0) == sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK(sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0) == sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
CHECK(sf::Transform(0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f) == STATIC_CHECK(sf::Transform(0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f) ==
sf::Transform(0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f)); sf::Transform(0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f));
CHECK(sf::Transform(1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f) == STATIC_CHECK(sf::Transform(1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f) ==
sf::Transform(1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f)); sf::Transform(1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f));
} }
SUBCASE("operator!=") SECTION("operator!=")
{ {
CHECK_FALSE(sf::Transform::Identity != sf::Transform::Identity); STATIC_CHECK_FALSE(sf::Transform::Identity != sf::Transform::Identity);
CHECK_FALSE(sf::Transform() != sf::Transform()); STATIC_CHECK_FALSE(sf::Transform() != sf::Transform());
CHECK_FALSE(sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK_FALSE(sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
CHECK_FALSE(sf::Transform(0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f) != STATIC_CHECK_FALSE(
sf::Transform(0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f)); sf::Transform(0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f) !=
CHECK_FALSE(sf::Transform(1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f) != sf::Transform(0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f, 0.0001f));
sf::Transform(1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f)); STATIC_CHECK_FALSE(
sf::Transform(1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f) !=
sf::Transform(1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f, 1000.0f));
CHECK(sf::Transform(1, 0, 0, 0, 0, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK(sf::Transform(1, 0, 0, 0, 0, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
CHECK(sf::Transform(0, 1, 0, 0, 0, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK(sf::Transform(0, 1, 0, 0, 0, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
CHECK(sf::Transform(0, 0, 1, 0, 0, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK(sf::Transform(0, 0, 1, 0, 0, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
CHECK(sf::Transform(0, 0, 0, 1, 0, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK(sf::Transform(0, 0, 0, 1, 0, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
CHECK(sf::Transform(0, 0, 0, 0, 1, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK(sf::Transform(0, 0, 0, 0, 1, 0, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
CHECK(sf::Transform(0, 0, 0, 0, 0, 1, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK(sf::Transform(0, 0, 0, 0, 0, 1, 0, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
CHECK(sf::Transform(0, 0, 0, 0, 0, 0, 1, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK(sf::Transform(0, 0, 0, 0, 0, 0, 1, 0, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
CHECK(sf::Transform(0, 0, 0, 0, 0, 0, 0, 1, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK(sf::Transform(0, 0, 0, 0, 0, 0, 0, 1, 0) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
CHECK(sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 1) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0)); STATIC_CHECK(sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 1) != sf::Transform(0, 0, 0, 0, 0, 0, 0, 0, 0));
} }
} }
} }

25
test/Graphics/Transformable.test.cpp
View File

@ -1,18 +1,21 @@
#include <SFML/Graphics/Transformable.hpp> #include <SFML/Graphics/Transformable.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::Transformable>);
static_assert(std::is_copy_assignable_v<sf::Transformable>);
static_assert(std::is_nothrow_move_constructible_v<sf::Transformable>);
static_assert(std::is_nothrow_move_assignable_v<sf::Transformable>);
TEST_CASE("[Graphics] sf::Transformable") TEST_CASE("[Graphics] sf::Transformable")
{ {
SUBCASE("Construction") SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::Transformable>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Transformable>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Transformable>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Transformable>);
}
SECTION("Construction")
{ {
const sf::Transformable transformable; const sf::Transformable transformable;
CHECK(transformable.getPosition() == sf::Vector2f(0, 0)); CHECK(transformable.getPosition() == sf::Vector2f(0, 0));
@ -23,7 +26,7 @@ TEST_CASE("[Graphics] sf::Transformable")
CHECK(transformable.getInverseTransform() == sf::Transform()); CHECK(transformable.getInverseTransform() == sf::Transform());
} }
SUBCASE("Setters and getters") SECTION("Setters and getters")
{ {
sf::Transformable transformable; sf::Transformable transformable;
@ -84,7 +87,7 @@ TEST_CASE("[Graphics] sf::Transformable")
CHECK(transformable.getInverseTransform().getMatrix()[15] == Approx(inverseTransform.getMatrix()[15])); CHECK(transformable.getInverseTransform().getMatrix()[15] == Approx(inverseTransform.getMatrix()[15]));
} }
SUBCASE("move()") SECTION("move()")
{ {
sf::Transformable transformable; sf::Transformable transformable;
CHECK(transformable.getPosition() == sf::Vector2f(0, 0)); CHECK(transformable.getPosition() == sf::Vector2f(0, 0));
@ -94,7 +97,7 @@ TEST_CASE("[Graphics] sf::Transformable")
CHECK(transformable.getPosition() == sf::Vector2f(-6, 12)); CHECK(transformable.getPosition() == sf::Vector2f(-6, 12));
} }
SUBCASE("rotate()") SECTION("rotate()")
{ {
sf::Transformable transformable; sf::Transformable transformable;
CHECK(transformable.getRotation() == sf::Angle::Zero); CHECK(transformable.getRotation() == sf::Angle::Zero);
@ -110,7 +113,7 @@ TEST_CASE("[Graphics] sf::Transformable")
CHECK(transformable.getRotation() == sf::degrees(340)); CHECK(transformable.getRotation() == sf::degrees(340));
} }
SUBCASE("scale()") SECTION("scale()")
{ {
sf::Transformable transformable; sf::Transformable transformable;
CHECK(transformable.getScale() == sf::Vector2f(1, 1)); CHECK(transformable.getScale() == sf::Vector2f(1, 1));

97
test/Graphics/Vertex.test.cpp
View File

@ -1,65 +1,60 @@
#include <SFML/Graphics/Vertex.hpp> #include <SFML/Graphics/Vertex.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::Vertex>);
static_assert(std::is_copy_assignable_v<sf::Vertex>);
static_assert(std::is_nothrow_move_constructible_v<sf::Vertex>);
static_assert(std::is_nothrow_move_assignable_v<sf::Vertex>);
TEST_CASE("[Graphics] sf::Vertex") TEST_CASE("[Graphics] sf::Vertex")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::Vertex>);
{ STATIC_CHECK(std::is_copy_assignable_v<sf::Vertex>);
const sf::Vertex vertex; STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Vertex>);
CHECK(vertex.position == sf::Vector2f(0.0f, 0.0f)); STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Vertex>);
CHECK(vertex.color == sf::Color(255, 255, 255));
CHECK(vertex.texCoords == sf::Vector2f(0.0f, 0.0f));
}
SUBCASE("Position constructor")
{
const sf::Vertex vertex({1, 2});
CHECK(vertex.position == sf::Vector2f(1.0f, 2.0f));
CHECK(vertex.color == sf::Color(255, 255, 255));
CHECK(vertex.texCoords == sf::Vector2f(0.0f, 0.0f));
}
SUBCASE("Position and color constructor")
{
const sf::Vertex vertex({1, 2}, {3, 4, 5, 6});
CHECK(vertex.position == sf::Vector2f(1.0f, 2.0f));
CHECK(vertex.color == sf::Color(3, 4, 5, 6));
CHECK(vertex.texCoords == sf::Vector2f(0.0f, 0.0f));
}
SUBCASE("Position and coords constructor")
{
const sf::Vertex vertex({1, 2}, {3, 4});
CHECK(vertex.position == sf::Vector2f(1.0f, 2.0f));
CHECK(vertex.color == sf::Color(255, 255, 255));
CHECK(vertex.texCoords == sf::Vector2f(3.0f, 4.0f));
}
SUBCASE("Position, color, and coords constructor")
{
const sf::Vertex vertex({1, 2}, {3, 4, 5, 6}, {7, 8});
CHECK(vertex.position == sf::Vector2f(1.0f, 2.0f));
CHECK(vertex.color == sf::Color(3, 4, 5, 6));
CHECK(vertex.texCoords == sf::Vector2f(7.0f, 8.0f));
}
} }
SUBCASE("Constexpr support") SECTION("Construction")
{ {
constexpr sf::Vertex vertex({1, 2}, {3, 4, 5, 6}, {7, 8}); SECTION("Default constructor")
static_assert(vertex.position == sf::Vector2f(1.0f, 2.0f)); {
static_assert(vertex.color == sf::Color(3, 4, 5, 6)); constexpr sf::Vertex vertex;
static_assert(vertex.texCoords == sf::Vector2f(7.0f, 8.0f)); STATIC_CHECK(vertex.position == sf::Vector2f(0.0f, 0.0f));
STATIC_CHECK(vertex.color == sf::Color(255, 255, 255));
STATIC_CHECK(vertex.texCoords == sf::Vector2f(0.0f, 0.0f));
}
SECTION("Position constructor")
{
constexpr sf::Vertex vertex({1, 2});
STATIC_CHECK(vertex.position == sf::Vector2f(1.0f, 2.0f));
STATIC_CHECK(vertex.color == sf::Color(255, 255, 255));
STATIC_CHECK(vertex.texCoords == sf::Vector2f(0.0f, 0.0f));
}
SECTION("Position and color constructor")
{
constexpr sf::Vertex vertex({1, 2}, {3, 4, 5, 6});
STATIC_CHECK(vertex.position == sf::Vector2f(1.0f, 2.0f));
STATIC_CHECK(vertex.color == sf::Color(3, 4, 5, 6));
STATIC_CHECK(vertex.texCoords == sf::Vector2f(0.0f, 0.0f));
}
SECTION("Position and coords constructor")
{
constexpr sf::Vertex vertex({1, 2}, {3, 4});
STATIC_CHECK(vertex.position == sf::Vector2f(1.0f, 2.0f));
STATIC_CHECK(vertex.color == sf::Color(255, 255, 255));
STATIC_CHECK(vertex.texCoords == sf::Vector2f(3.0f, 4.0f));
}
SECTION("Position, color, and coords constructor")
{
constexpr sf::Vertex vertex({1, 2}, {3, 4, 5, 6}, {7, 8});
STATIC_CHECK(vertex.position == sf::Vector2f(1.0f, 2.0f));
STATIC_CHECK(vertex.color == sf::Color(3, 4, 5, 6));
STATIC_CHECK(vertex.texCoords == sf::Vector2f(7.0f, 8.0f));
}
} }
} }

35
test/Graphics/VertexArray.test.cpp
View File

@ -1,20 +1,23 @@
#include <SFML/Graphics/VertexArray.hpp> #include <SFML/Graphics/VertexArray.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::VertexArray>);
static_assert(std::is_copy_assignable_v<sf::VertexArray>);
static_assert(std::is_nothrow_move_constructible_v<sf::VertexArray>);
static_assert(std::is_nothrow_move_assignable_v<sf::VertexArray>);
TEST_CASE("[Graphics] sf::VertexArray") TEST_CASE("[Graphics] sf::VertexArray")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::VertexArray>);
STATIC_CHECK(std::is_copy_assignable_v<sf::VertexArray>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::VertexArray>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::VertexArray>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::VertexArray vertexArray; const sf::VertexArray vertexArray;
CHECK(vertexArray.getVertexCount() == 0); CHECK(vertexArray.getVertexCount() == 0);
@ -22,7 +25,7 @@ TEST_CASE("[Graphics] sf::VertexArray")
CHECK(vertexArray.getBounds() == sf::FloatRect({0, 0}, {0, 0})); CHECK(vertexArray.getBounds() == sf::FloatRect({0, 0}, {0, 0}));
} }
SUBCASE("Explicit constructor with default argument") SECTION("Explicit constructor with default argument")
{ {
const sf::VertexArray vertexArray(sf::PrimitiveType::Lines); const sf::VertexArray vertexArray(sf::PrimitiveType::Lines);
CHECK(vertexArray.getVertexCount() == 0); CHECK(vertexArray.getVertexCount() == 0);
@ -30,7 +33,7 @@ TEST_CASE("[Graphics] sf::VertexArray")
CHECK(vertexArray.getBounds() == sf::FloatRect({0, 0}, {0, 0})); CHECK(vertexArray.getBounds() == sf::FloatRect({0, 0}, {0, 0}));
} }
SUBCASE("Explicit constructor") SECTION("Explicit constructor")
{ {
const sf::VertexArray vertexArray(sf::PrimitiveType::Lines, 10); const sf::VertexArray vertexArray(sf::PrimitiveType::Lines, 10);
CHECK(vertexArray.getVertexCount() == 10); CHECK(vertexArray.getVertexCount() == 10);
@ -45,7 +48,7 @@ TEST_CASE("[Graphics] sf::VertexArray")
} }
} }
SUBCASE("Resize array") SECTION("Resize array")
{ {
sf::VertexArray vertexArray; sf::VertexArray vertexArray;
vertexArray.resize(42); vertexArray.resize(42);
@ -58,7 +61,7 @@ TEST_CASE("[Graphics] sf::VertexArray")
} }
} }
SUBCASE("Clear array") SECTION("Clear array")
{ {
sf::VertexArray vertexArray; sf::VertexArray vertexArray;
vertexArray.append({}); vertexArray.append({});
@ -66,7 +69,7 @@ TEST_CASE("[Graphics] sf::VertexArray")
CHECK(vertexArray.getVertexCount() == 0); CHECK(vertexArray.getVertexCount() == 0);
} }
SUBCASE("Append to array") SECTION("Append to array")
{ {
sf::VertexArray vertexArray; sf::VertexArray vertexArray;
const sf::Vertex vertex({1, 2}, {3, 4, 5, 6}, {7, 8}); const sf::Vertex vertex({1, 2}, {3, 4, 5, 6}, {7, 8});
@ -77,7 +80,7 @@ TEST_CASE("[Graphics] sf::VertexArray")
CHECK(vertexArray[0].texCoords == vertex.texCoords); CHECK(vertexArray[0].texCoords == vertex.texCoords);
} }
SUBCASE("Write to array") SECTION("Write to array")
{ {
sf::VertexArray vertexArray; sf::VertexArray vertexArray;
vertexArray.resize(10); vertexArray.resize(10);
@ -88,14 +91,14 @@ TEST_CASE("[Graphics] sf::VertexArray")
CHECK(vertexArray[9].texCoords == otherVertex.texCoords); CHECK(vertexArray[9].texCoords == otherVertex.texCoords);
} }
SUBCASE("Set primitive type") SECTION("Set primitive type")
{ {
sf::VertexArray vertexArray; sf::VertexArray vertexArray;
vertexArray.setPrimitiveType(sf::PrimitiveType::TriangleStrip); vertexArray.setPrimitiveType(sf::PrimitiveType::TriangleStrip);
CHECK(vertexArray.getPrimitiveType() == sf::PrimitiveType::TriangleStrip); CHECK(vertexArray.getPrimitiveType() == sf::PrimitiveType::TriangleStrip);
} }
SUBCASE("Get bounds") SECTION("Get bounds")
{ {
sf::VertexArray vertexArray; sf::VertexArray vertexArray;
vertexArray.append(sf::Vertex({1, 1})); vertexArray.append(sf::Vertex({1, 1}));

63
test/Graphics/VertexBuffer.test.cpp
View File

@ -3,30 +3,33 @@
// Other first party headers // Other first party headers
#include <SFML/Graphics/Vertex.hpp> #include <SFML/Graphics/Vertex.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <array> #include <array>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::VertexBuffer>); // Skip these tests with [.display] because they produce flakey failures in CI when using xvfb-run
static_assert(std::is_copy_assignable_v<sf::VertexBuffer>); TEST_CASE("[Graphics] sf::VertexBuffer", "[.display]")
static_assert(std::is_move_constructible_v<sf::VertexBuffer>);
static_assert(!std::is_nothrow_move_constructible_v<sf::VertexBuffer>);
static_assert(std::is_move_assignable_v<sf::VertexBuffer>);
static_assert(!std::is_nothrow_move_assignable_v<sf::VertexBuffer>);
static_assert(std::is_nothrow_swappable_v<sf::VertexBuffer>);
// Skip these tests because they produce flakey failures in CI when using xvfb-run
TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
{ {
SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::VertexBuffer>);
STATIC_CHECK(std::is_copy_assignable_v<sf::VertexBuffer>);
STATIC_CHECK(std::is_move_constructible_v<sf::VertexBuffer>);
STATIC_CHECK(!std::is_nothrow_move_constructible_v<sf::VertexBuffer>);
STATIC_CHECK(std::is_move_assignable_v<sf::VertexBuffer>);
STATIC_CHECK(!std::is_nothrow_move_assignable_v<sf::VertexBuffer>);
STATIC_CHECK(std::is_nothrow_swappable_v<sf::VertexBuffer>);
}
// Skip tests if vertex buffers aren't available // Skip tests if vertex buffers aren't available
if (!sf::VertexBuffer::isAvailable()) if (!sf::VertexBuffer::isAvailable())
return; return;
SUBCASE("Construction") SECTION("Construction")
{ {
SUBCASE("Default constructor") SECTION("Default constructor")
{ {
const sf::VertexBuffer vertexBuffer; const sf::VertexBuffer vertexBuffer;
CHECK(vertexBuffer.getVertexCount() == 0); CHECK(vertexBuffer.getVertexCount() == 0);
@ -35,7 +38,7 @@ TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
CHECK(vertexBuffer.getUsage() == sf::VertexBuffer::Stream); CHECK(vertexBuffer.getUsage() == sf::VertexBuffer::Stream);
} }
SUBCASE("Primitive type constructor") SECTION("Primitive type constructor")
{ {
const sf::VertexBuffer vertexBuffer(sf::PrimitiveType::Triangles); const sf::VertexBuffer vertexBuffer(sf::PrimitiveType::Triangles);
CHECK(vertexBuffer.getVertexCount() == 0); CHECK(vertexBuffer.getVertexCount() == 0);
@ -44,7 +47,7 @@ TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
CHECK(vertexBuffer.getUsage() == sf::VertexBuffer::Stream); CHECK(vertexBuffer.getUsage() == sf::VertexBuffer::Stream);
} }
SUBCASE("Usage constructor") SECTION("Usage constructor")
{ {
const sf::VertexBuffer vertexBuffer(sf::VertexBuffer::Static); const sf::VertexBuffer vertexBuffer(sf::VertexBuffer::Static);
CHECK(vertexBuffer.getVertexCount() == 0); CHECK(vertexBuffer.getVertexCount() == 0);
@ -53,7 +56,7 @@ TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
CHECK(vertexBuffer.getUsage() == sf::VertexBuffer::Static); CHECK(vertexBuffer.getUsage() == sf::VertexBuffer::Static);
} }
SUBCASE("Primitive type and usage constructor") SECTION("Primitive type and usage constructor")
{ {
const sf::VertexBuffer vertexBuffer(sf::PrimitiveType::LineStrip, sf::VertexBuffer::Dynamic); const sf::VertexBuffer vertexBuffer(sf::PrimitiveType::LineStrip, sf::VertexBuffer::Dynamic);
CHECK(vertexBuffer.getVertexCount() == 0); CHECK(vertexBuffer.getVertexCount() == 0);
@ -63,11 +66,11 @@ TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
} }
} }
SUBCASE("Copy semantics") SECTION("Copy semantics")
{ {
const sf::VertexBuffer vertexBuffer(sf::PrimitiveType::LineStrip, sf::VertexBuffer::Dynamic); const sf::VertexBuffer vertexBuffer(sf::PrimitiveType::LineStrip, sf::VertexBuffer::Dynamic);
SUBCASE("Construction") SECTION("Construction")
{ {
const sf::VertexBuffer vertexBufferCopy(vertexBuffer); // NOLINT(performance-unnecessary-copy-initialization) const sf::VertexBuffer vertexBufferCopy(vertexBuffer); // NOLINT(performance-unnecessary-copy-initialization)
CHECK(vertexBufferCopy.getVertexCount() == 0); CHECK(vertexBufferCopy.getVertexCount() == 0);
@ -76,7 +79,7 @@ TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
CHECK(vertexBufferCopy.getUsage() == sf::VertexBuffer::Dynamic); CHECK(vertexBufferCopy.getUsage() == sf::VertexBuffer::Dynamic);
} }
SUBCASE("Assignment") SECTION("Assignment")
{ {
sf::VertexBuffer vertexBufferCopy; sf::VertexBuffer vertexBufferCopy;
vertexBufferCopy = vertexBuffer; vertexBufferCopy = vertexBuffer;
@ -87,28 +90,28 @@ TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
} }
} }
SUBCASE("create()") SECTION("create()")
{ {
sf::VertexBuffer vertexBuffer; sf::VertexBuffer vertexBuffer;
CHECK(vertexBuffer.create(100)); CHECK(vertexBuffer.create(100));
CHECK(vertexBuffer.getVertexCount() == 100); CHECK(vertexBuffer.getVertexCount() == 100);
} }
SUBCASE("update()") SECTION("update()")
{ {
sf::VertexBuffer vertexBuffer; sf::VertexBuffer vertexBuffer;
std::array<sf::Vertex, 128> vertices{}; std::array<sf::Vertex, 128> vertices{};
SUBCASE("Vertices") SECTION("Vertices")
{ {
SUBCASE("Uninitialized buffer") SECTION("Uninitialized buffer")
{ {
CHECK(!vertexBuffer.update(vertices.data())); CHECK(!vertexBuffer.update(vertices.data()));
} }
CHECK(vertexBuffer.create(128)); CHECK(vertexBuffer.create(128));
SUBCASE("Null vertices") SECTION("Null vertices")
{ {
CHECK(!vertexBuffer.update(nullptr)); CHECK(!vertexBuffer.update(nullptr));
} }
@ -118,11 +121,11 @@ TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
CHECK(vertexBuffer.getNativeHandle() != 0); CHECK(vertexBuffer.getNativeHandle() != 0);
} }
SUBCASE("Vertices, count, and offset") SECTION("Vertices, count, and offset")
{ {
CHECK(vertexBuffer.create(128)); CHECK(vertexBuffer.create(128));
SUBCASE("Count + offset too large") SECTION("Count + offset too large")
{ {
CHECK(!vertexBuffer.update(vertices.data(), 100, 100)); CHECK(!vertexBuffer.update(vertices.data(), 100, 100));
} }
@ -131,7 +134,7 @@ TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
CHECK(vertexBuffer.getVertexCount() == 128); CHECK(vertexBuffer.getVertexCount() == 128);
} }
SUBCASE("Another buffer") SECTION("Another buffer")
{ {
sf::VertexBuffer otherVertexBuffer; sf::VertexBuffer otherVertexBuffer;
@ -141,7 +144,7 @@ TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
} }
} }
SUBCASE("swap()") SECTION("swap()")
{ {
sf::VertexBuffer vertexBuffer1(sf::PrimitiveType::LineStrip, sf::VertexBuffer::Dynamic); sf::VertexBuffer vertexBuffer1(sf::PrimitiveType::LineStrip, sf::VertexBuffer::Dynamic);
CHECK(vertexBuffer1.create(50)); CHECK(vertexBuffer1.create(50));
@ -162,14 +165,14 @@ TEST_CASE("[Graphics] sf::VertexBuffer" * doctest::skip(true))
CHECK(vertexBuffer2.getUsage() == sf::VertexBuffer::Dynamic); CHECK(vertexBuffer2.getUsage() == sf::VertexBuffer::Dynamic);
} }
SUBCASE("Set/get primitive type") SECTION("Set/get primitive type")
{ {
sf::VertexBuffer vertexBuffer; sf::VertexBuffer vertexBuffer;
vertexBuffer.setPrimitiveType(sf::PrimitiveType::TriangleFan); vertexBuffer.setPrimitiveType(sf::PrimitiveType::TriangleFan);
CHECK(vertexBuffer.getPrimitiveType() == sf::PrimitiveType::TriangleFan); CHECK(vertexBuffer.getPrimitiveType() == sf::PrimitiveType::TriangleFan);
} }
SUBCASE("Set/get usage") SECTION("Set/get usage")
{ {
sf::VertexBuffer vertexBuffer; sf::VertexBuffer vertexBuffer;
vertexBuffer.setUsage(sf::VertexBuffer::Dynamic); vertexBuffer.setUsage(sf::VertexBuffer::Dynamic);

39
test/Graphics/View.test.cpp
View File

@ -1,20 +1,23 @@
#include <SFML/Graphics/View.hpp> #include <SFML/Graphics/View.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::View>);
static_assert(std::is_copy_assignable_v<sf::View>);
static_assert(std::is_nothrow_move_constructible_v<sf::View>);
static_assert(std::is_nothrow_move_assignable_v<sf::View>);
TEST_CASE("[Graphics] sf::View") TEST_CASE("[Graphics] sf::View")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::View>);
STATIC_CHECK(std::is_copy_assignable_v<sf::View>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::View>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::View>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::View view; const sf::View view;
CHECK(view.getCenter() == sf::Vector2f(500, 500)); CHECK(view.getCenter() == sf::Vector2f(500, 500));
@ -25,7 +28,7 @@ TEST_CASE("[Graphics] sf::View")
CHECK(view.getInverseTransform() == Approx(sf::Transform(500, 0, 500, 0, -500, 500, 0, 0, 1))); CHECK(view.getInverseTransform() == Approx(sf::Transform(500, 0, 500, 0, -500, 500, 0, 0, 1)));
} }
SUBCASE("Rectangle constructor") SECTION("Rectangle constructor")
{ {
const sf::View view(sf::FloatRect({10, 20}, {400, 600})); const sf::View view(sf::FloatRect({10, 20}, {400, 600}));
CHECK(view.getCenter() == sf::Vector2f(210, 320)); CHECK(view.getCenter() == sf::Vector2f(210, 320));
@ -36,7 +39,7 @@ TEST_CASE("[Graphics] sf::View")
CHECK(view.getInverseTransform() == Approx(sf::Transform(200, 0, 210, 0, -300, 320, 0, 0, 1))); CHECK(view.getInverseTransform() == Approx(sf::Transform(200, 0, 210, 0, -300, 320, 0, 0, 1)));
} }
SUBCASE("Center + size constructor") SECTION("Center + size constructor")
{ {
const sf::View view({520, 960}, {1080, 1920}); const sf::View view({520, 960}, {1080, 1920});
CHECK(view.getCenter() == sf::Vector2f(520, 960)); CHECK(view.getCenter() == sf::Vector2f(520, 960));
@ -48,7 +51,7 @@ TEST_CASE("[Graphics] sf::View")
} }
} }
SUBCASE("Set/get center") SECTION("Set/get center")
{ {
sf::View view; sf::View view;
view.setCenter({3.14f, 4.2f}); view.setCenter({3.14f, 4.2f});
@ -57,7 +60,7 @@ TEST_CASE("[Graphics] sf::View")
CHECK(view.getInverseTransform() == Approx(sf::Transform(500, 0, 3.14f, 0, -500, 4.2f, 0, 0, 1))); CHECK(view.getInverseTransform() == Approx(sf::Transform(500, 0, 3.14f, 0, -500, 4.2f, 0, 0, 1)));
} }
SUBCASE("Set/get size") SECTION("Set/get size")
{ {
sf::View view; sf::View view;
view.setSize({600, 900}); view.setSize({600, 900});
@ -66,7 +69,7 @@ TEST_CASE("[Graphics] sf::View")
CHECK(view.getInverseTransform() == Approx(sf::Transform(300, 0, 500, 0, -450, 500, 0, 0, 1))); CHECK(view.getInverseTransform() == Approx(sf::Transform(300, 0, 500, 0, -450, 500, 0, 0, 1)));
} }
SUBCASE("Set/get rotation") SECTION("Set/get rotation")
{ {
sf::View view; sf::View view;
view.setRotation(sf::degrees(-345)); view.setRotation(sf::degrees(-345));
@ -83,7 +86,7 @@ TEST_CASE("[Graphics] sf::View")
Approx(sf::Transform(383.022f, 321.394f, 500, 321.394f, -383.022f, 500, 0, 0, 1))); Approx(sf::Transform(383.022f, 321.394f, 500, 321.394f, -383.022f, 500, 0, 0, 1)));
} }
SUBCASE("Set/get viewport") SECTION("Set/get viewport")
{ {
sf::View view; sf::View view;
view.setViewport({{150, 250}, {500, 750}}); view.setViewport({{150, 250}, {500, 750}});
@ -92,7 +95,7 @@ TEST_CASE("[Graphics] sf::View")
CHECK(view.getInverseTransform() == Approx(sf::Transform(500, 0, 500, 0, -500, 500, 0, 0, 1))); CHECK(view.getInverseTransform() == Approx(sf::Transform(500, 0, 500, 0, -500, 500, 0, 0, 1)));
} }
SUBCASE("reset()") SECTION("reset()")
{ {
sf::View view; sf::View view;
view.setCenter({3.14f, 4.2f}); view.setCenter({3.14f, 4.2f});
@ -108,7 +111,7 @@ TEST_CASE("[Graphics] sf::View")
CHECK(view.getInverseTransform() == Approx(sf::Transform(1.5f, 0, 2.5f, 0, -2, 4, 0, 0, 1))); CHECK(view.getInverseTransform() == Approx(sf::Transform(1.5f, 0, 2.5f, 0, -2, 4, 0, 0, 1)));
} }
SUBCASE("move()") SECTION("move()")
{ {
sf::View view; sf::View view;
view.setCenter({25, 25}); view.setCenter({25, 25});
@ -118,7 +121,7 @@ TEST_CASE("[Graphics] sf::View")
CHECK(view.getInverseTransform() == Approx(sf::Transform(500, 0, 40, 0, -500, 50, 0, 0, 1))); CHECK(view.getInverseTransform() == Approx(sf::Transform(500, 0, 40, 0, -500, 50, 0, 0, 1)));
} }
SUBCASE("rotate()") SECTION("rotate()")
{ {
sf::View view; sf::View view;
view.setRotation(sf::degrees(45)); view.setRotation(sf::degrees(45));
@ -129,7 +132,7 @@ TEST_CASE("[Graphics] sf::View")
CHECK(view.getInverseTransform() == Approx(sf::Transform(433.013f, 250, 500, 250, -433.013f, 500, 0, 0, 1))); CHECK(view.getInverseTransform() == Approx(sf::Transform(433.013f, 250, 500, 250, -433.013f, 500, 0, 0, 1)));
} }
SUBCASE("zoom()") SECTION("zoom()")
{ {
sf::View view; sf::View view;
view.setSize({25, 25}); view.setSize({25, 25});

49
test/Network/IpAddress.test.cpp
View File

@ -1,6 +1,6 @@
#include <SFML/Network/IpAddress.hpp> #include <SFML/Network/IpAddress.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <sstream> #include <sstream>
#include <string_view> #include <string_view>
@ -9,16 +9,19 @@
using namespace std::string_literals; using namespace std::string_literals;
using namespace std::string_view_literals; using namespace std::string_view_literals;
static_assert(std::is_copy_constructible_v<sf::IpAddress>);
static_assert(std::is_copy_assignable_v<sf::IpAddress>);
static_assert(std::is_nothrow_move_constructible_v<sf::IpAddress>);
static_assert(std::is_nothrow_move_assignable_v<sf::IpAddress>);
TEST_CASE("[Network] sf::IpAddress") TEST_CASE("[Network] sf::IpAddress")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("static 'create' function") STATIC_CHECK(std::is_copy_constructible_v<sf::IpAddress>);
STATIC_CHECK(std::is_copy_assignable_v<sf::IpAddress>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::IpAddress>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::IpAddress>);
}
SECTION("Construction")
{
SECTION("static 'create' function")
{ {
const auto ipAddress = sf::IpAddress::resolve("203.0.113.2"sv); const auto ipAddress = sf::IpAddress::resolve("203.0.113.2"sv);
REQUIRE(ipAddress.has_value()); REQUIRE(ipAddress.has_value());
@ -50,14 +53,14 @@ TEST_CASE("[Network] sf::IpAddress")
CHECK(!sf::IpAddress::resolve("").has_value()); CHECK(!sf::IpAddress::resolve("").has_value());
} }
SUBCASE("Byte constructor") SECTION("Byte constructor")
{ {
const sf::IpAddress ipAddress(198, 51, 100, 234); const sf::IpAddress ipAddress(198, 51, 100, 234);
CHECK(ipAddress.toString() == "198.51.100.234"s); CHECK(ipAddress.toString() == "198.51.100.234"s);
CHECK(ipAddress.toInteger() == 0xC63364EA); CHECK(ipAddress.toInteger() == 0xC63364EA);
} }
SUBCASE("std::uint32_t constructor") SECTION("std::uint32_t constructor")
{ {
const sf::IpAddress ipAddress(0xCB00719A); const sf::IpAddress ipAddress(0xCB00719A);
CHECK(ipAddress.toString() == "203.0.113.154"s); CHECK(ipAddress.toString() == "203.0.113.154"s);
@ -65,9 +68,9 @@ TEST_CASE("[Network] sf::IpAddress")
} }
} }
SUBCASE("Static functions") SECTION("Static functions")
{ {
SUBCASE("getLocalAddress") SECTION("getLocalAddress")
{ {
const std::optional<sf::IpAddress> ipAddress = sf::IpAddress::getLocalAddress(); const std::optional<sf::IpAddress> ipAddress = sf::IpAddress::getLocalAddress();
REQUIRE(ipAddress.has_value()); REQUIRE(ipAddress.has_value());
@ -75,7 +78,7 @@ TEST_CASE("[Network] sf::IpAddress")
CHECK(ipAddress->toInteger() != 0); CHECK(ipAddress->toInteger() != 0);
} }
SUBCASE("getPublicAddress") SECTION("getPublicAddress")
{ {
const std::optional<sf::IpAddress> ipAddress = sf::IpAddress::getPublicAddress(sf::seconds(1)); const std::optional<sf::IpAddress> ipAddress = sf::IpAddress::getPublicAddress(sf::seconds(1));
if (ipAddress.has_value()) if (ipAddress.has_value())
@ -86,7 +89,7 @@ TEST_CASE("[Network] sf::IpAddress")
} }
} }
SUBCASE("Static constants") SECTION("Static constants")
{ {
CHECK(sf::IpAddress::Any.toString() == "0.0.0.0"s); CHECK(sf::IpAddress::Any.toString() == "0.0.0.0"s);
CHECK(sf::IpAddress::Any.toInteger() == 0); CHECK(sf::IpAddress::Any.toInteger() == 0);
@ -98,21 +101,21 @@ TEST_CASE("[Network] sf::IpAddress")
CHECK(sf::IpAddress::Broadcast.toInteger() == 0xFFFFFFFF); CHECK(sf::IpAddress::Broadcast.toInteger() == 0xFFFFFFFF);
} }
SUBCASE("Operators") SECTION("Operators")
{ {
SUBCASE("operator==") SECTION("operator==")
{ {
CHECK(sf::IpAddress(0xC6, 0x33, 0x64, 0x7B) == sf::IpAddress(0xC633647B)); CHECK(sf::IpAddress(0xC6, 0x33, 0x64, 0x7B) == sf::IpAddress(0xC633647B));
CHECK(sf::IpAddress(0xCB0071D2) == sf::IpAddress(203, 0, 113, 210)); CHECK(sf::IpAddress(0xCB0071D2) == sf::IpAddress(203, 0, 113, 210));
} }
SUBCASE("operator!=") SECTION("operator!=")
{ {
CHECK(sf::IpAddress(0x12344321) != sf::IpAddress(1234)); CHECK(sf::IpAddress(0x12344321) != sf::IpAddress(1234));
CHECK(sf::IpAddress(198, 51, 100, 1) != sf::IpAddress(198, 51, 100, 11)); CHECK(sf::IpAddress(198, 51, 100, 1) != sf::IpAddress(198, 51, 100, 11));
} }
SUBCASE("operator<") SECTION("operator<")
{ {
CHECK(sf::IpAddress(1) < sf::IpAddress(2)); CHECK(sf::IpAddress(1) < sf::IpAddress(2));
CHECK(sf::IpAddress(0, 0, 0, 0) < sf::IpAddress(1, 0, 0, 0)); CHECK(sf::IpAddress(0, 0, 0, 0) < sf::IpAddress(1, 0, 0, 0));
@ -122,7 +125,7 @@ TEST_CASE("[Network] sf::IpAddress")
CHECK(sf::IpAddress(0, 0, 0, 1) < sf::IpAddress(1, 0, 0, 1)); CHECK(sf::IpAddress(0, 0, 0, 1) < sf::IpAddress(1, 0, 0, 1));
} }
SUBCASE("operator>") SECTION("operator>")
{ {
CHECK(sf::IpAddress(2) > sf::IpAddress(1)); CHECK(sf::IpAddress(2) > sf::IpAddress(1));
CHECK(sf::IpAddress(1, 0, 0, 0) > sf::IpAddress(0, 0, 0, 0)); CHECK(sf::IpAddress(1, 0, 0, 0) > sf::IpAddress(0, 0, 0, 0));
@ -132,7 +135,7 @@ TEST_CASE("[Network] sf::IpAddress")
CHECK(sf::IpAddress(1, 0, 0, 1) > sf::IpAddress(0, 0, 0, 1)); CHECK(sf::IpAddress(1, 0, 0, 1) > sf::IpAddress(0, 0, 0, 1));
} }
SUBCASE("operator<=") SECTION("operator<=")
{ {
CHECK(sf::IpAddress(1) <= sf::IpAddress(2)); CHECK(sf::IpAddress(1) <= sf::IpAddress(2));
CHECK(sf::IpAddress(0, 0, 0, 0) <= sf::IpAddress(1, 0, 0, 0)); CHECK(sf::IpAddress(0, 0, 0, 0) <= sf::IpAddress(1, 0, 0, 0));
@ -145,7 +148,7 @@ TEST_CASE("[Network] sf::IpAddress")
CHECK(sf::IpAddress(0xCB0071D2) <= sf::IpAddress(203, 0, 113, 210)); CHECK(sf::IpAddress(0xCB0071D2) <= sf::IpAddress(203, 0, 113, 210));
} }
SUBCASE("operator>=") SECTION("operator>=")
{ {
CHECK(sf::IpAddress(2) >= sf::IpAddress(1)); CHECK(sf::IpAddress(2) >= sf::IpAddress(1));
CHECK(sf::IpAddress(1, 0, 0, 0) >= sf::IpAddress(0, 0, 0, 0)); CHECK(sf::IpAddress(1, 0, 0, 0) >= sf::IpAddress(0, 0, 0, 0));
@ -158,7 +161,7 @@ TEST_CASE("[Network] sf::IpAddress")
CHECK(sf::IpAddress(0xCB0071D2) >= sf::IpAddress(203, 0, 113, 210)); CHECK(sf::IpAddress(0xCB0071D2) >= sf::IpAddress(203, 0, 113, 210));
} }
SUBCASE("operator>>") SECTION("operator>>")
{ {
std::optional<sf::IpAddress> ipAddress; std::optional<sf::IpAddress> ipAddress;
std::istringstream("198.51.100.4") >> ipAddress; std::istringstream("198.51.100.4") >> ipAddress;
@ -175,7 +178,7 @@ TEST_CASE("[Network] sf::IpAddress")
CHECK(!ipAddress.has_value()); CHECK(!ipAddress.has_value());
} }
SUBCASE("operator<<") SECTION("operator<<")
{ {
std::ostringstream out; std::ostringstream out;
out << sf::IpAddress(192, 0, 2, 10); out << sf::IpAddress(192, 0, 2, 10);

29
test/Network/Packet.test.cpp
View File

@ -1,16 +1,11 @@
#include <SFML/Network/Packet.hpp> #include <SFML/Network/Packet.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <array> #include <array>
#include <limits> #include <limits>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::Packet>);
static_assert(std::is_copy_assignable_v<sf::Packet>);
static_assert(std::is_nothrow_move_constructible_v<sf::Packet>);
static_assert(std::is_nothrow_move_assignable_v<sf::Packet>);
#define CHECK_PACKET_STREAM_OPERATORS(expected) \ #define CHECK_PACKET_STREAM_OPERATORS(expected) \
do \ do \
{ \ { \
@ -34,7 +29,15 @@ static_assert(std::is_nothrow_move_assignable_v<sf::Packet>);
TEST_CASE("[Network] sf::Packet") TEST_CASE("[Network] sf::Packet")
{ {
SUBCASE("Default constructor") SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::Packet>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Packet>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Packet>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Packet>);
}
SECTION("Default constructor")
{ {
const sf::Packet packet; const sf::Packet packet;
CHECK(packet.getReadPosition() == 0); CHECK(packet.getReadPosition() == 0);
@ -44,7 +47,7 @@ TEST_CASE("[Network] sf::Packet")
CHECK(static_cast<bool>(packet)); CHECK(static_cast<bool>(packet));
} }
SUBCASE("Append and clear") SECTION("Append and clear")
{ {
constexpr std::array data = {1, 2, 3, 4, 5, 6}; constexpr std::array data = {1, 2, 3, 4, 5, 6};
@ -64,9 +67,9 @@ TEST_CASE("[Network] sf::Packet")
CHECK(static_cast<bool>(packet)); CHECK(static_cast<bool>(packet));
} }
SUBCASE("Stream operators") SECTION("Stream operators")
{ {
SUBCASE("std::int8_t") SECTION("std::int8_t")
{ {
CHECK_PACKET_STREAM_OPERATORS(std::int8_t(0)); CHECK_PACKET_STREAM_OPERATORS(std::int8_t(0));
CHECK_PACKET_STREAM_OPERATORS(std::int8_t(1)); CHECK_PACKET_STREAM_OPERATORS(std::int8_t(1));
@ -74,7 +77,7 @@ TEST_CASE("[Network] sf::Packet")
CHECK_PACKET_STREAM_OPERATORS(std::numeric_limits<std::int8_t>::max()); CHECK_PACKET_STREAM_OPERATORS(std::numeric_limits<std::int8_t>::max());
} }
SUBCASE("std::int16_t") SECTION("std::int16_t")
{ {
CHECK_PACKET_STREAM_OPERATORS(std::int16_t(0)); CHECK_PACKET_STREAM_OPERATORS(std::int16_t(0));
CHECK_PACKET_STREAM_OPERATORS(std::int16_t(1)); CHECK_PACKET_STREAM_OPERATORS(std::int16_t(1));
@ -82,7 +85,7 @@ TEST_CASE("[Network] sf::Packet")
CHECK_PACKET_STREAM_OPERATORS(std::numeric_limits<std::int16_t>::max()); CHECK_PACKET_STREAM_OPERATORS(std::numeric_limits<std::int16_t>::max());
} }
SUBCASE("std::int32_t") SECTION("std::int32_t")
{ {
CHECK_PACKET_STREAM_OPERATORS(std::int32_t(0)); CHECK_PACKET_STREAM_OPERATORS(std::int32_t(0));
CHECK_PACKET_STREAM_OPERATORS(std::int32_t(1)); CHECK_PACKET_STREAM_OPERATORS(std::int32_t(1));
@ -90,7 +93,7 @@ TEST_CASE("[Network] sf::Packet")
CHECK_PACKET_STREAM_OPERATORS(std::numeric_limits<std::int32_t>::max()); CHECK_PACKET_STREAM_OPERATORS(std::numeric_limits<std::int32_t>::max());
} }
SUBCASE("std::int64_t") SECTION("std::int64_t")
{ {
CHECK_PACKET_STREAM_OPERATORS(std::int64_t(0)); CHECK_PACKET_STREAM_OPERATORS(std::int64_t(0));
CHECK_PACKET_STREAM_OPERATORS(std::int64_t(1)); CHECK_PACKET_STREAM_OPERATORS(std::int64_t(1));

400
test/System/Angle.test.cpp
View File

@ -1,187 +1,187 @@
#include <SFML/System/Angle.hpp> #include <SFML/System/Angle.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <SystemUtil.hpp> #include <SystemUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::Angle>);
static_assert(std::is_copy_assignable_v<sf::Angle>);
static_assert(std::is_nothrow_move_constructible_v<sf::Angle>);
static_assert(std::is_nothrow_move_assignable_v<sf::Angle>);
TEST_CASE("[System] sf::Angle") TEST_CASE("[System] sf::Angle")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::Angle>);
{ STATIC_CHECK(std::is_copy_assignable_v<sf::Angle>);
const sf::Angle angle; STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Angle>);
CHECK(angle.asDegrees() == 0.f); STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Angle>);
CHECK(angle.asRadians() == 0.f);
}
SUBCASE("wrapSigned()")
{
CHECK(sf::Angle::Zero.wrapSigned() == sf::Angle::Zero);
CHECK(sf::degrees(0).wrapSigned() == sf::degrees(0));
CHECK(sf::degrees(1).wrapSigned() == sf::degrees(1));
CHECK(sf::degrees(-1).wrapSigned() == sf::degrees(-1));
CHECK(sf::degrees(90).wrapSigned() == sf::degrees(90));
CHECK(sf::degrees(-90).wrapSigned() == sf::degrees(-90));
CHECK(sf::degrees(180).wrapSigned() == sf::degrees(-180));
CHECK(sf::degrees(-180).wrapSigned() == sf::degrees(-180));
CHECK(sf::degrees(360).wrapSigned() == sf::degrees(0));
CHECK(sf::degrees(-360).wrapSigned() == sf::degrees(0));
CHECK(sf::degrees(720).wrapSigned() == sf::degrees(0));
CHECK(sf::degrees(-720).wrapSigned() == sf::degrees(0));
}
SUBCASE("wrapUnsigned()")
{
CHECK(sf::Angle::Zero.wrapUnsigned() == sf::Angle::Zero);
CHECK(sf::degrees(0).wrapUnsigned() == sf::degrees(0));
CHECK(sf::degrees(1).wrapUnsigned() == sf::degrees(1));
CHECK(sf::degrees(-1).wrapUnsigned() == sf::degrees(359));
CHECK(sf::degrees(90).wrapUnsigned() == sf::degrees(90));
CHECK(sf::degrees(-90).wrapUnsigned() == sf::degrees(270));
CHECK(sf::degrees(180).wrapUnsigned() == sf::degrees(180));
CHECK(sf::degrees(-180).wrapUnsigned() == sf::degrees(180));
CHECK(sf::degrees(360).wrapUnsigned() == sf::degrees(0));
CHECK(sf::degrees(-360).wrapUnsigned() == sf::degrees(0));
CHECK(sf::degrees(720).wrapUnsigned() == sf::degrees(0));
CHECK(sf::degrees(-720).wrapUnsigned() == sf::degrees(0));
}
SUBCASE("degrees()")
{
const sf::Angle angle = sf::degrees(15);
CHECK(angle == sf::degrees(15));
CHECK(angle.asRadians() == Approx(0.26179939f));
const sf::Angle bigAngle = sf::degrees(1000);
CHECK(bigAngle == sf::degrees(1000));
CHECK(bigAngle.asRadians() == Approx(17.453293f));
const sf::Angle bigNegativeAngle = sf::degrees(-4321);
CHECK(bigNegativeAngle == sf::degrees(-4321));
CHECK(bigNegativeAngle.asRadians() == Approx(-75.415677f));
}
SUBCASE("radians()")
{
const sf::Angle angle = sf::radians(1);
CHECK(angle.asDegrees() == Approx(57.2957795f));
CHECK(angle.asRadians() == Approx(1.f));
const sf::Angle bigAngle = sf::radians(72);
CHECK(bigAngle.asDegrees() == Approx(4125.29612f));
CHECK(bigAngle.asRadians() == Approx(72.f));
const sf::Angle bigNegativeAngle = sf::radians(-200);
CHECK(bigNegativeAngle.asDegrees() == Approx(-11459.1559f));
CHECK(bigNegativeAngle.asRadians() == Approx(-200.f));
}
} }
SUBCASE("Constants") SECTION("Construction")
{ {
CHECK(sf::Angle::Zero.asDegrees() == 0.f); constexpr sf::Angle angle;
CHECK(sf::Angle::Zero.asRadians() == 0.f); STATIC_CHECK(angle.asDegrees() == 0.f);
STATIC_CHECK(angle.asRadians() == 0.f);
} }
SUBCASE("Operators") SECTION("wrapSigned()")
{ {
SUBCASE("operator==") STATIC_CHECK(sf::Angle::Zero.wrapSigned() == sf::Angle::Zero);
STATIC_CHECK(sf::degrees(0).wrapSigned() == sf::degrees(0));
STATIC_CHECK(sf::degrees(1).wrapSigned() == sf::degrees(1));
STATIC_CHECK(sf::degrees(-1).wrapSigned() == sf::degrees(-1));
STATIC_CHECK(sf::degrees(90).wrapSigned() == sf::degrees(90));
STATIC_CHECK(sf::degrees(-90).wrapSigned() == sf::degrees(-90));
STATIC_CHECK(sf::degrees(180).wrapSigned() == sf::degrees(-180));
STATIC_CHECK(sf::degrees(-180).wrapSigned() == sf::degrees(-180));
STATIC_CHECK(sf::degrees(360).wrapSigned() == sf::degrees(0));
STATIC_CHECK(sf::degrees(-360).wrapSigned() == sf::degrees(0));
STATIC_CHECK(sf::degrees(720).wrapSigned() == sf::degrees(0));
STATIC_CHECK(sf::degrees(-720).wrapSigned() == sf::degrees(0));
}
SECTION("wrapUnsigned()")
{
STATIC_CHECK(sf::Angle::Zero.wrapUnsigned() == sf::Angle::Zero);
STATIC_CHECK(sf::degrees(0).wrapUnsigned() == sf::degrees(0));
STATIC_CHECK(sf::degrees(1).wrapUnsigned() == sf::degrees(1));
STATIC_CHECK(sf::degrees(-1).wrapUnsigned() == sf::degrees(359));
STATIC_CHECK(sf::degrees(90).wrapUnsigned() == sf::degrees(90));
STATIC_CHECK(sf::degrees(-90).wrapUnsigned() == sf::degrees(270));
STATIC_CHECK(sf::degrees(180).wrapUnsigned() == sf::degrees(180));
STATIC_CHECK(sf::degrees(-180).wrapUnsigned() == sf::degrees(180));
STATIC_CHECK(sf::degrees(360).wrapUnsigned() == sf::degrees(0));
STATIC_CHECK(sf::degrees(-360).wrapUnsigned() == sf::degrees(0));
STATIC_CHECK(sf::degrees(720).wrapUnsigned() == sf::degrees(0));
STATIC_CHECK(sf::degrees(-720).wrapUnsigned() == sf::degrees(0));
}
SECTION("degrees()")
{
constexpr sf::Angle angle = sf::degrees(15);
STATIC_CHECK(angle == sf::degrees(15));
CHECK(angle.asRadians() == Approx(0.26179939f));
constexpr sf::Angle bigAngle = sf::degrees(1000);
STATIC_CHECK(bigAngle == sf::degrees(1000));
CHECK(bigAngle.asRadians() == Approx(17.453293f));
constexpr sf::Angle bigNegativeAngle = sf::degrees(-4321);
STATIC_CHECK(bigNegativeAngle == sf::degrees(-4321));
CHECK(bigNegativeAngle.asRadians() == Approx(-75.415677f));
}
SECTION("radians()")
{
constexpr sf::Angle angle = sf::radians(1);
CHECK(angle.asDegrees() == Approx(57.2957795f));
CHECK(angle.asRadians() == Approx(1.f));
constexpr sf::Angle bigAngle = sf::radians(72);
CHECK(bigAngle.asDegrees() == Approx(4125.29612f));
CHECK(bigAngle.asRadians() == Approx(72.f));
constexpr sf::Angle bigNegativeAngle = sf::radians(-200);
CHECK(bigNegativeAngle.asDegrees() == Approx(-11459.1559f));
CHECK(bigNegativeAngle.asRadians() == Approx(-200.f));
}
SECTION("Constants")
{
STATIC_CHECK(sf::Angle::Zero.asDegrees() == 0.f);
STATIC_CHECK(sf::Angle::Zero.asRadians() == 0.f);
}
SECTION("Operators")
{
SECTION("operator==")
{ {
CHECK(sf::Angle() == sf::Angle()); STATIC_CHECK(sf::Angle() == sf::Angle());
CHECK(sf::Angle() == sf::Angle::Zero); STATIC_CHECK(sf::Angle() == sf::Angle::Zero);
CHECK(sf::Angle() == sf::degrees(0)); STATIC_CHECK(sf::Angle() == sf::degrees(0));
CHECK(sf::Angle() == sf::radians(0)); STATIC_CHECK(sf::Angle() == sf::radians(0));
CHECK(sf::degrees(0) == sf::radians(0)); STATIC_CHECK(sf::degrees(0) == sf::radians(0));
CHECK(sf::degrees(15) == sf::degrees(15)); STATIC_CHECK(sf::degrees(15) == sf::degrees(15));
CHECK(sf::radians(1) == sf::radians(1)); STATIC_CHECK(sf::radians(1) == sf::radians(1));
CHECK(sf::degrees(360) == sf::degrees(360)); STATIC_CHECK(sf::degrees(360) == sf::degrees(360));
CHECK(sf::degrees(720) == sf::degrees(720)); STATIC_CHECK(sf::degrees(720) == sf::degrees(720));
} }
SUBCASE("operator!=") SECTION("operator!=")
{ {
CHECK(sf::Angle() != sf::radians(2)); STATIC_CHECK(sf::Angle() != sf::radians(2));
CHECK(sf::degrees(1) != sf::radians(1)); STATIC_CHECK(sf::degrees(1) != sf::radians(1));
CHECK(sf::radians(0) != sf::radians(0.1f)); STATIC_CHECK(sf::radians(0) != sf::radians(0.1f));
} }
SUBCASE("operator<") SECTION("operator<")
{ {
CHECK(sf::radians(0) < sf::degrees(0.1f)); STATIC_CHECK(sf::radians(0) < sf::degrees(0.1f));
CHECK(sf::degrees(0) < sf::radians(0.1f)); STATIC_CHECK(sf::degrees(0) < sf::radians(0.1f));
CHECK(sf::radians(-0.1f) < sf::radians(0)); STATIC_CHECK(sf::radians(-0.1f) < sf::radians(0));
CHECK(sf::degrees(-0.1f) < sf::degrees(0)); STATIC_CHECK(sf::degrees(-0.1f) < sf::degrees(0));
} }
SUBCASE("operator>") SECTION("operator>")
{ {
CHECK(sf::radians(0.1f) > sf::degrees(0)); STATIC_CHECK(sf::radians(0.1f) > sf::degrees(0));
CHECK(sf::degrees(0.1f) > sf::radians(0)); STATIC_CHECK(sf::degrees(0.1f) > sf::radians(0));
CHECK(sf::radians(0) > sf::radians(-0.1f)); STATIC_CHECK(sf::radians(0) > sf::radians(-0.1f));
CHECK(sf::degrees(0) > sf::degrees(-0.1f)); STATIC_CHECK(sf::degrees(0) > sf::degrees(-0.1f));
} }
SUBCASE("operator<=") SECTION("operator<=")
{ {
CHECK(sf::radians(0) <= sf::degrees(0.1f)); STATIC_CHECK(sf::radians(0) <= sf::degrees(0.1f));
CHECK(sf::degrees(0) <= sf::radians(0.1f)); STATIC_CHECK(sf::degrees(0) <= sf::radians(0.1f));
CHECK(sf::radians(-0.1f) <= sf::radians(0)); STATIC_CHECK(sf::radians(-0.1f) <= sf::radians(0));
CHECK(sf::degrees(-0.1f) <= sf::degrees(0)); STATIC_CHECK(sf::degrees(-0.1f) <= sf::degrees(0));
CHECK(sf::Angle() <= sf::Angle()); STATIC_CHECK(sf::Angle() <= sf::Angle());
CHECK(sf::Angle() <= sf::Angle::Zero); STATIC_CHECK(sf::Angle() <= sf::Angle::Zero);
CHECK(sf::Angle() <= sf::degrees(0)); STATIC_CHECK(sf::Angle() <= sf::degrees(0));
CHECK(sf::Angle() <= sf::radians(0)); STATIC_CHECK(sf::Angle() <= sf::radians(0));
CHECK(sf::degrees(0) <= sf::radians(0)); STATIC_CHECK(sf::degrees(0) <= sf::radians(0));
CHECK(sf::degrees(15) <= sf::degrees(15)); STATIC_CHECK(sf::degrees(15) <= sf::degrees(15));
CHECK(sf::radians(1) <= sf::radians(1)); STATIC_CHECK(sf::radians(1) <= sf::radians(1));
CHECK(sf::degrees(360) <= sf::degrees(360)); STATIC_CHECK(sf::degrees(360) <= sf::degrees(360));
CHECK(sf::degrees(720) <= sf::degrees(720)); STATIC_CHECK(sf::degrees(720) <= sf::degrees(720));
} }
SUBCASE("operator>=") SECTION("operator>=")
{ {
CHECK(sf::radians(0.1f) >= sf::degrees(0)); STATIC_CHECK(sf::radians(0.1f) >= sf::degrees(0));
CHECK(sf::degrees(0.1f) >= sf::radians(0)); STATIC_CHECK(sf::degrees(0.1f) >= sf::radians(0));
CHECK(sf::radians(0) >= sf::radians(-0.1f)); STATIC_CHECK(sf::radians(0) >= sf::radians(-0.1f));
CHECK(sf::degrees(0) >= sf::degrees(-0.1f)); STATIC_CHECK(sf::degrees(0) >= sf::degrees(-0.1f));
CHECK(sf::Angle() >= sf::Angle()); STATIC_CHECK(sf::Angle() >= sf::Angle());
CHECK(sf::Angle() >= sf::Angle::Zero); STATIC_CHECK(sf::Angle() >= sf::Angle::Zero);
CHECK(sf::Angle() >= sf::degrees(0)); STATIC_CHECK(sf::Angle() >= sf::degrees(0));
CHECK(sf::Angle() >= sf::radians(0)); STATIC_CHECK(sf::Angle() >= sf::radians(0));
CHECK(sf::degrees(0) >= sf::radians(0)); STATIC_CHECK(sf::degrees(0) >= sf::radians(0));
CHECK(sf::degrees(15) >= sf::degrees(15)); STATIC_CHECK(sf::degrees(15) >= sf::degrees(15));
CHECK(sf::radians(1) >= sf::radians(1)); STATIC_CHECK(sf::radians(1) >= sf::radians(1));
CHECK(sf::degrees(360) >= sf::degrees(360)); STATIC_CHECK(sf::degrees(360) >= sf::degrees(360));
CHECK(sf::degrees(720) >= sf::degrees(720)); STATIC_CHECK(sf::degrees(720) >= sf::degrees(720));
} }
SUBCASE("Unary operator-") SECTION("Unary operator-")
{ {
CHECK(-sf::Angle() == sf::Angle()); STATIC_CHECK(-sf::Angle() == sf::Angle());
CHECK(-sf::radians(-1) == sf::radians(1)); STATIC_CHECK(-sf::radians(-1) == sf::radians(1));
CHECK(-sf::degrees(15) == sf::degrees(-15)); STATIC_CHECK(-sf::degrees(15) == sf::degrees(-15));
CHECK(-sf::radians(1) == sf::radians(-1)); STATIC_CHECK(-sf::radians(1) == sf::radians(-1));
} }
SUBCASE("operator+") SECTION("operator+")
{ {
CHECK(sf::Angle() + sf::Angle() == sf::Angle()); STATIC_CHECK(sf::Angle() + sf::Angle() == sf::Angle());
CHECK(sf::Angle::Zero + sf::radians(0.5f) == sf::radians(0.5f)); STATIC_CHECK(sf::Angle::Zero + sf::radians(0.5f) == sf::radians(0.5f));
CHECK(sf::radians(6) + sf::radians(0.5f) == sf::radians(6.5f)); STATIC_CHECK(sf::radians(6) + sf::radians(0.5f) == sf::radians(6.5f));
CHECK(sf::radians(10) + sf::radians(0.5f) == sf::radians(10.5f)); STATIC_CHECK(sf::radians(10) + sf::radians(0.5f) == sf::radians(10.5f));
CHECK(sf::degrees(360) + sf::degrees(360) == sf::degrees(720)); STATIC_CHECK(sf::degrees(360) + sf::degrees(360) == sf::degrees(720));
} }
SUBCASE("operator+=") SECTION("operator+=")
{ {
sf::Angle angle = sf::degrees(-15); sf::Angle angle = sf::degrees(-15);
angle += sf::degrees(15); angle += sf::degrees(15);
@ -190,15 +190,15 @@ TEST_CASE("[System] sf::Angle")
CHECK(angle == sf::radians(10)); CHECK(angle == sf::radians(10));
} }
SUBCASE("operator-") SECTION("operator-")
{ {
CHECK(sf::Angle() - sf::Angle() == sf::Angle()); STATIC_CHECK(sf::Angle() - sf::Angle() == sf::Angle());
CHECK(sf::radians(1) - sf::radians(0.5f) == sf::radians(0.5f)); STATIC_CHECK(sf::radians(1) - sf::radians(0.5f) == sf::radians(0.5f));
CHECK(sf::Angle::Zero - sf::radians(0.5f) == sf::radians(-0.5f)); STATIC_CHECK(sf::Angle::Zero - sf::radians(0.5f) == sf::radians(-0.5f));
CHECK(sf::degrees(900) - sf::degrees(1) == sf::degrees(899)); STATIC_CHECK(sf::degrees(900) - sf::degrees(1) == sf::degrees(899));
} }
SUBCASE("operator-=") SECTION("operator-=")
{ {
sf::Angle angle = sf::degrees(15); sf::Angle angle = sf::degrees(15);
angle -= sf::degrees(15); angle -= sf::degrees(15);
@ -207,101 +207,89 @@ TEST_CASE("[System] sf::Angle")
CHECK(angle == sf::radians(-10)); CHECK(angle == sf::radians(-10));
} }
SUBCASE("operator*") SECTION("operator*")
{ {
CHECK(sf::radians(0) * 10 == sf::Angle::Zero); STATIC_CHECK(sf::radians(0) * 10 == sf::Angle::Zero);
CHECK(sf::degrees(10) * 2.5f == sf::degrees(25)); STATIC_CHECK(sf::degrees(10) * 2.5f == sf::degrees(25));
CHECK(sf::degrees(100) * 10.0f == sf::degrees(1000)); STATIC_CHECK(sf::degrees(100) * 10.0f == sf::degrees(1000));
CHECK(10 * sf::radians(0) == sf::Angle::Zero); STATIC_CHECK(10 * sf::radians(0) == sf::Angle::Zero);
CHECK(2.5f * sf::degrees(10) == sf::degrees(25)); STATIC_CHECK(2.5f * sf::degrees(10) == sf::degrees(25));
CHECK(10.0f * sf::degrees(100) == sf::degrees(1000)); STATIC_CHECK(10.0f * sf::degrees(100) == sf::degrees(1000));
} }
SUBCASE("operator*=") SECTION("operator*=")
{ {
sf::Angle angle = sf::degrees(1); sf::Angle angle = sf::degrees(1);
angle *= 10; angle *= 10;
CHECK(angle == sf::degrees(10)); CHECK(angle == sf::degrees(10));
} }
SUBCASE("operator/") SECTION("operator/")
{ {
CHECK(sf::Angle::Zero / 10 == sf::Angle::Zero); STATIC_CHECK(sf::Angle::Zero / 10 == sf::Angle::Zero);
CHECK(sf::degrees(10) / 2.5f == sf::degrees(4)); STATIC_CHECK(sf::degrees(10) / 2.5f == sf::degrees(4));
CHECK(sf::radians(12) / 3 == sf::radians(4)); STATIC_CHECK(sf::radians(12) / 3 == sf::radians(4));
CHECK(sf::Angle::Zero / sf::degrees(1) == 0.f); STATIC_CHECK(sf::Angle::Zero / sf::degrees(1) == 0.f);
CHECK(sf::degrees(10) / sf::degrees(10) == 1.f); STATIC_CHECK(sf::degrees(10) / sf::degrees(10) == 1.f);
CHECK(sf::radians(10) / sf::radians(2) == Approx(5.f)); CHECK(sf::radians(10) / sf::radians(2) == Approx(5.f));
} }
SUBCASE("operator/=") SECTION("operator/=")
{ {
sf::Angle angle = sf::degrees(60); sf::Angle angle = sf::degrees(60);
angle /= 5; angle /= 5;
CHECK(angle == sf::degrees(12)); CHECK(angle == sf::degrees(12));
} }
SUBCASE("operator%") SECTION("operator%")
{ {
CHECK(sf::Angle::Zero % sf::radians(0.5f) == sf::Angle::Zero); STATIC_CHECK(sf::Angle::Zero % sf::radians(0.5f) == sf::Angle::Zero);
CHECK(sf::radians(10) % sf::radians(1) == sf::radians(0)); STATIC_CHECK(sf::radians(10) % sf::radians(1) == sf::radians(0));
CHECK(sf::degrees(90) % sf::degrees(30) == sf::degrees(0)); STATIC_CHECK(sf::degrees(90) % sf::degrees(30) == sf::degrees(0));
CHECK(sf::degrees(90) % sf::degrees(40) == sf::degrees(10)); STATIC_CHECK(sf::degrees(90) % sf::degrees(40) == sf::degrees(10));
CHECK(sf::degrees(-90) % sf::degrees(30) == sf::degrees(0)); STATIC_CHECK(sf::degrees(-90) % sf::degrees(30) == sf::degrees(0));
CHECK(sf::degrees(-90) % sf::degrees(40) == sf::degrees(30)); STATIC_CHECK(sf::degrees(-90) % sf::degrees(40) == sf::degrees(30));
} }
SUBCASE("operator%=") SECTION("operator%=")
{ {
sf::Angle angle = sf::degrees(59); sf::Angle angle = sf::degrees(59);
angle %= sf::degrees(10); angle %= sf::degrees(10);
CHECK(angle == sf::degrees(9)); CHECK(angle == sf::degrees(9));
} }
SUBCASE("operator _deg") SECTION("operator _deg")
{ {
using namespace sf::Literals; using namespace sf::Literals;
CHECK(0.0_deg == sf::Angle::Zero); STATIC_CHECK(0.0_deg == sf::Angle::Zero);
CHECK(1.0_deg == sf::degrees(1)); STATIC_CHECK(1.0_deg == sf::degrees(1));
CHECK(-1.0_deg == sf::degrees(-1)); STATIC_CHECK(-1.0_deg == sf::degrees(-1));
CHECK(3.14_deg == sf::degrees(3.14f)); STATIC_CHECK(3.14_deg == sf::degrees(3.14f));
CHECK(-3.14_deg == sf::degrees(-3.14f)); STATIC_CHECK(-3.14_deg == sf::degrees(-3.14f));
CHECK(0_deg == sf::Angle::Zero); STATIC_CHECK(0_deg == sf::Angle::Zero);
CHECK(1_deg == sf::degrees(1)); STATIC_CHECK(1_deg == sf::degrees(1));
CHECK(-1_deg == sf::degrees(-1)); STATIC_CHECK(-1_deg == sf::degrees(-1));
CHECK(100_deg == sf::degrees(100)); STATIC_CHECK(100_deg == sf::degrees(100));
CHECK(-100_deg == sf::degrees(-100)); STATIC_CHECK(-100_deg == sf::degrees(-100));
} }
SUBCASE("operator _rad") SECTION("operator _rad")
{ {
using namespace sf::Literals; using namespace sf::Literals;
CHECK(0.0_rad == sf::Angle::Zero); STATIC_CHECK(0.0_rad == sf::Angle::Zero);
CHECK(1.0_rad == sf::radians(1)); STATIC_CHECK(1.0_rad == sf::radians(1));
CHECK(-1.0_rad == sf::radians(-1)); STATIC_CHECK(-1.0_rad == sf::radians(-1));
CHECK(3.14_rad == sf::radians(3.14f)); STATIC_CHECK(3.14_rad == sf::radians(3.14f));
CHECK(-3.14_rad == sf::radians(-3.14f)); STATIC_CHECK(-3.14_rad == sf::radians(-3.14f));
CHECK(0_rad == sf::Angle::Zero); STATIC_CHECK(0_rad == sf::Angle::Zero);
CHECK(1_rad == sf::radians(1)); STATIC_CHECK(1_rad == sf::radians(1));
CHECK(-1_rad == sf::radians(-1)); STATIC_CHECK(-1_rad == sf::radians(-1));
CHECK(100_rad == sf::radians(100)); STATIC_CHECK(100_rad == sf::radians(100));
CHECK(-100_rad == sf::radians(-100)); STATIC_CHECK(-100_rad == sf::radians(-100));
} }
} }
SUBCASE("Constexpr support")
{
constexpr auto result = []
{
sf::Angle angle = sf::degrees(9);
angle %= sf::degrees(2);
return angle;
}();
static_assert(result == sf::degrees(1));
}
} }

19
test/System/Clock.test.cpp
View File

@ -1,20 +1,23 @@
#include <SFML/System/Clock.hpp> #include <SFML/System/Clock.hpp>
#include <SFML/System/Time.hpp> #include <SFML/System/Time.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <SystemUtil.hpp> #include <SystemUtil.hpp>
#include <thread> #include <thread>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::Clock>);
static_assert(std::is_copy_assignable_v<sf::Clock>);
static_assert(std::is_nothrow_move_constructible_v<sf::Clock>);
static_assert(std::is_nothrow_move_assignable_v<sf::Clock>);
TEST_CASE("[System] sf::Clock") TEST_CASE("[System] sf::Clock")
{ {
SUBCASE("getElapsedTime()") SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::Clock>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Clock>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Clock>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Clock>);
}
SECTION("getElapsedTime()")
{ {
const sf::Clock clock; const sf::Clock clock;
CHECK(clock.getElapsedTime() >= sf::microseconds(0)); CHECK(clock.getElapsedTime() >= sf::microseconds(0));
@ -23,7 +26,7 @@ TEST_CASE("[System] sf::Clock")
CHECK(clock.getElapsedTime() > elapsed); CHECK(clock.getElapsedTime() > elapsed);
} }
SUBCASE("restart()") SECTION("restart()")
{ {
sf::Clock clock; sf::Clock clock;
CHECK(clock.restart() >= sf::microseconds(0)); CHECK(clock.restart() >= sf::microseconds(0));

12
test/System/Config.test.cpp
View File

@ -1,14 +1,14 @@
#include <SFML/Config.hpp> #include <SFML/Config.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
TEST_CASE("[System] SFML/Config.hpp") TEST_CASE("[System] SFML/Config.hpp")
{ {
SUBCASE("Version macros") SECTION("Version macros")
{ {
CHECK(SFML_VERSION_MAJOR == EXPECTED_SFML_VERSION_MAJOR); STATIC_CHECK(SFML_VERSION_MAJOR == EXPECTED_SFML_VERSION_MAJOR);
CHECK(SFML_VERSION_MINOR == EXPECTED_SFML_VERSION_MINOR); STATIC_CHECK(SFML_VERSION_MINOR == EXPECTED_SFML_VERSION_MINOR);
CHECK(SFML_VERSION_PATCH == EXPECTED_SFML_VERSION_PATCH); STATIC_CHECK(SFML_VERSION_PATCH == EXPECTED_SFML_VERSION_PATCH);
CHECK(SFML_VERSION_IS_RELEASE == EXPECTED_SFML_VERSION_IS_RELEASE); STATIC_CHECK(SFML_VERSION_IS_RELEASE == EXPECTED_SFML_VERSION_IS_RELEASE);
} }
} }

8
test/System/Err.test.cpp
View File

@ -1,21 +1,21 @@
#include <SFML/System/Err.hpp> #include <SFML/System/Err.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <sstream> #include <sstream>
TEST_CASE("[System] sf::err") TEST_CASE("[System] sf::err")
{ {
SUBCASE("Overflow default buffer") SECTION("Overflow default buffer")
{ {
// No assertion macros in this subcase since nothing about this can be directly observed. // No assertion macros in this section since nothing about this can be directly observed.
// Intention is to ensure DefaultErrStreamBuf::overflow gets called. // Intention is to ensure DefaultErrStreamBuf::overflow gets called.
sf::err() << "SFML is a simple, fast, cross-platform and object-oriented multimedia API." sf::err() << "SFML is a simple, fast, cross-platform and object-oriented multimedia API."
"It provides access to windowing, graphics, audio and network." "It provides access to windowing, graphics, audio and network."
"It is written in C++, and has bindings for various languages such as C, .Net, Ruby, Python."; "It is written in C++, and has bindings for various languages such as C, .Net, Ruby, Python.";
} }
SUBCASE("Redirect buffer to observe contents") SECTION("Redirect buffer to observe contents")
{ {
sf::err() << "We'll never be able to observe this" << std::endl; // Ensure buffer is flushed sf::err() << "We'll never be able to observe this" << std::endl; // Ensure buffer is flushed
auto* const defaultStreamBuffer = sf::err().rdbuf(); auto* const defaultStreamBuffer = sf::err().rdbuf();

21
test/System/FileInputStream.test.cpp
View File

@ -1,6 +1,6 @@
#include <SFML/System/FileInputStream.hpp> #include <SFML/System/FileInputStream.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <fstream> #include <fstream>
#include <sstream> #include <sstream>
@ -10,11 +10,6 @@
#include <cassert> #include <cassert>
static_assert(!std::is_copy_constructible_v<sf::FileInputStream>);
static_assert(!std::is_copy_assignable_v<sf::FileInputStream>);
static_assert(std::is_nothrow_move_constructible_v<sf::FileInputStream>);
static_assert(std::is_nothrow_move_assignable_v<sf::FileInputStream>);
namespace namespace
{ {
std::string getTemporaryFilePath() std::string getTemporaryFilePath()
@ -70,7 +65,15 @@ public:
TEST_CASE("[System] sf::FileInputStream") TEST_CASE("[System] sf::FileInputStream")
{ {
SUBCASE("Empty stream") SECTION("Type traits")
{
STATIC_CHECK(!std::is_copy_constructible_v<sf::FileInputStream>);
STATIC_CHECK(!std::is_copy_assignable_v<sf::FileInputStream>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::FileInputStream>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::FileInputStream>);
}
SECTION("Empty stream")
{ {
sf::FileInputStream fis; sf::FileInputStream fis;
@ -79,7 +82,7 @@ TEST_CASE("[System] sf::FileInputStream")
CHECK(fis.tell() == -1); CHECK(fis.tell() == -1);
} }
SUBCASE("Temporary file stream") SECTION("Temporary file stream")
{ {
const std::string fileContents = "hello world"; const std::string fileContents = "hello world";
@ -93,7 +96,7 @@ TEST_CASE("[System] sf::FileInputStream")
CHECK(fis.read(buffer, 5) == 5); CHECK(fis.read(buffer, 5) == 5);
CHECK(std::string_view(buffer, 5) == std::string_view(fileContents.c_str(), 5)); CHECK(std::string_view(buffer, 5) == std::string_view(fileContents.c_str(), 5));
SUBCASE("Move semantics") SECTION("Move semantics")
{ {
sf::FileInputStream fis2 = std::move(fis); sf::FileInputStream fis2 = std::move(fis);

14
test/System/MemoryInputStream.test.cpp
View File

@ -1,13 +1,21 @@
#include <SFML/System/MemoryInputStream.hpp> #include <SFML/System/MemoryInputStream.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <ostream> #include <ostream>
#include <string_view> #include <string_view>
TEST_CASE("[System] sf::MemoryInputStream") TEST_CASE("[System] sf::MemoryInputStream")
{ {
SUBCASE("Empty stream") SECTION("Type traits")
{
STATIC_CHECK(std::is_copy_constructible_v<sf::MemoryInputStream>);
STATIC_CHECK(std::is_copy_assignable_v<sf::MemoryInputStream>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::MemoryInputStream>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::MemoryInputStream>);
}
SECTION("Empty stream")
{ {
sf::MemoryInputStream mis; sf::MemoryInputStream mis;
@ -17,7 +25,7 @@ TEST_CASE("[System] sf::MemoryInputStream")
CHECK(mis.getSize() == -1); CHECK(mis.getSize() == -1);
} }
SUBCASE("Open memory stream") SECTION("Open memory stream")
{ {
using namespace std::literals::string_view_literals; using namespace std::literals::string_view_literals;
constexpr auto memoryContents = "hello world"sv; constexpr auto memoryContents = "hello world"sv;

16
test/System/Sleep.test.cpp
View File

@ -3,26 +3,12 @@
// Other 1st party headers // Other 1st party headers
#include <SFML/System/Time.hpp> #include <SFML/System/Time.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <chrono> #include <chrono>
using namespace std::chrono_literals; using namespace std::chrono_literals;
// Specialize StringMaker for std::chrono::duration specializations
// https://github.com/doctest/doctest/blob/master/doc/markdown/stringification.md#docteststringmakert-specialisation
namespace doctest
{
template <typename Rep, typename Period>
struct StringMaker<std::chrono::duration<Rep, Period>>
{
static String convert(const std::chrono::duration<Rep, Period>& duration)
{
return toString(std::chrono::nanoseconds(duration).count()) + "ns";
}
};
} // namespace doctest
#define CHECK_SLEEP_DURATION(duration) \ #define CHECK_SLEEP_DURATION(duration) \
do \ do \
{ \ { \

120
test/System/String.test.cpp
View File

@ -1,6 +1,6 @@
#include <SFML/System/String.hpp> #include <SFML/System/String.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <GraphicsUtil.hpp> #include <GraphicsUtil.hpp>
#include <array> #include <array>
@ -10,11 +10,6 @@
#include <cassert> #include <cassert>
static_assert(std::is_copy_constructible_v<sf::String>);
static_assert(std::is_copy_assignable_v<sf::String>);
static_assert(std::is_nothrow_move_constructible_v<sf::String>);
static_assert(std::is_nothrow_move_assignable_v<sf::String>);
namespace namespace
{ {
// Return either argument depending on whether wchar_t is 16 or 32 bits // Return either argument depending on whether wchar_t is 16 or 32 bits
@ -42,58 +37,57 @@ auto toHex(const CharT character)
// Specialize StringMaker for alternative std::basic_string<T> specializations // Specialize StringMaker for alternative std::basic_string<T> specializations
// std::string's string conversion cannot be specialized but all other string types get special treatment // std::string's string conversion cannot be specialized but all other string types get special treatment
// https://github.com/doctest/doctest/blob/master/doc/markdown/stringification.md#docteststringmakert-specialisation // https://github.com/catchorg/Catch2/blob/devel/docs/tostring.md#catchstringmaker-specialisation
namespace doctest namespace Catch
{ {
template <typename CharT> template <>
struct StringMaker<std::basic_string<CharT>> struct StringMaker<std::basic_string<std::uint8_t>>
{ {
static String convert(const std::basic_string<CharT>& string) static std::string convert(const std::basic_string<std::uint8_t>& string)
{ {
doctest::String output; std::ostringstream output;
for (const auto character : string) for (const auto character : string)
{ {
if (character >= 32 && character < 127) if (character >= 32 && character < 127)
output += std::string(1, static_cast<char>(character)).c_str(); output << std::string(1, static_cast<char>(character));
else else
output += toHex(character).c_str(); output << toHex(character);
} }
return output; return output.str();
} }
}; };
} // namespace Catch
template <>
struct StringMaker<char32_t>
{
static String convert(const char32_t character)
{
return toHex(character).c_str();
}
};
} // namespace doctest
TEST_CASE("[System] sf::String") TEST_CASE("[System] sf::String")
{ {
using namespace std::string_literals; using namespace std::string_literals;
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::String>);
STATIC_CHECK(std::is_copy_assignable_v<sf::String>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::String>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::String>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::String string; const sf::String string;
CHECK(std::string(string) == ""s); CHECK(std::string(string) == ""s);
CHECK(std::wstring(string) == L""s); CHECK(std::wstring(string) == L""s);
CHECK(string.toAnsiString() == ""s); CHECK(string.toAnsiString() == ""s);
CHECK(string.toWideString() == L""s); CHECK(string.toWideString() == L""s);
CHECK(string.toUtf8() == std::basic_string<std::uint8_t>()); CHECK(string.toUtf8().empty());
CHECK(string.toUtf16() == u""s); CHECK(string.toUtf16().empty());
CHECK(string.toUtf32() == U""s); CHECK(string.toUtf32().empty());
CHECK(string.getSize() == 0); CHECK(string.getSize() == 0);
CHECK(string.isEmpty()); CHECK(string.isEmpty());
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("ANSI character constructor") SECTION("ANSI character constructor")
{ {
const sf::String string = 'a'; const sf::String string = 'a';
CHECK(std::string(string) == "a"s); CHECK(std::string(string) == "a"s);
@ -108,7 +102,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("ANSI C string constructor") SECTION("ANSI C string constructor")
{ {
const sf::String string = "def"; const sf::String string = "def";
CHECK(std::string(string) == "def"s); CHECK(std::string(string) == "def"s);
@ -123,7 +117,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("ANSI string constructor") SECTION("ANSI string constructor")
{ {
const sf::String string = "ghi"s; const sf::String string = "ghi"s;
CHECK(std::string(string) == "ghi"s); CHECK(std::string(string) == "ghi"s);
@ -138,7 +132,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("Wide character constructor") SECTION("Wide character constructor")
{ {
const sf::String string = L'\xFA'; const sf::String string = L'\xFA';
CHECK(std::string(string) == select("\xFA"s, "\0"s)); CHECK(std::string(string) == select("\xFA"s, "\0"s));
@ -153,7 +147,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("Wide C string constructor") SECTION("Wide C string constructor")
{ {
const sf::String string = L"j\xFAl"; const sf::String string = L"j\xFAl";
CHECK(std::string(string) == select("j\xFAl"s, "j\0l"s)); CHECK(std::string(string) == select("j\xFAl"s, "j\0l"s));
@ -168,7 +162,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("Wide string constructor") SECTION("Wide string constructor")
{ {
const sf::String string = L"mno\xFA"s; const sf::String string = L"mno\xFA"s;
CHECK(std::string(string) == select("mno\xFA"s, "mno\0"s)); CHECK(std::string(string) == select("mno\xFA"s, "mno\0"s));
@ -183,7 +177,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("UTF-32 character constructor") SECTION("UTF-32 character constructor")
{ {
const sf::String string = U'\U0010AFAF'; const sf::String string = U'\U0010AFAF';
CHECK(std::string(string) == "\0"s); CHECK(std::string(string) == "\0"s);
@ -198,7 +192,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("UTF-32 C string constructor") SECTION("UTF-32 C string constructor")
{ {
const sf::String string = U"\U0010ABCDrs"; const sf::String string = U"\U0010ABCDrs";
CHECK(std::string(string) == "\0rs"s); CHECK(std::string(string) == "\0rs"s);
@ -213,7 +207,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("UTF-32 string constructor") SECTION("UTF-32 string constructor")
{ {
const sf::String string = U"tuv\U00104321"s; const sf::String string = U"tuv\U00104321"s;
CHECK(std::string(string) == "tuv\0"s); CHECK(std::string(string) == "tuv\0"s);
@ -229,9 +223,9 @@ TEST_CASE("[System] sf::String")
} }
} }
SUBCASE("fromUtf8()") SECTION("fromUtf8()")
{ {
SUBCASE("Nominal") SECTION("Nominal")
{ {
constexpr std::array<std::uint8_t, 4> characters{'w', 'x', 'y', 'z'}; constexpr std::array<std::uint8_t, 4> characters{'w', 'x', 'y', 'z'};
const sf::String string = sf::String::fromUtf8(characters.begin(), characters.end()); const sf::String string = sf::String::fromUtf8(characters.begin(), characters.end());
@ -247,7 +241,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("Insufficient input") SECTION("Insufficient input")
{ {
constexpr std::array<std::uint8_t, 1> characters{251}; constexpr std::array<std::uint8_t, 1> characters{251};
const sf::String string = sf::String::fromUtf8(characters.begin(), characters.end()); const sf::String string = sf::String::fromUtf8(characters.begin(), characters.end());
@ -257,7 +251,7 @@ TEST_CASE("[System] sf::String")
} }
} }
SUBCASE("fromUtf16()") SECTION("fromUtf16()")
{ {
constexpr std::array<std::uint16_t, 4> characters{0xF1, 'x', 'y', 'z'}; constexpr std::array<std::uint16_t, 4> characters{0xF1, 'x', 'y', 'z'};
const sf::String string = sf::String::fromUtf16(characters.begin(), characters.end()); const sf::String string = sf::String::fromUtf16(characters.begin(), characters.end());
@ -273,7 +267,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("fromUtf32()") SECTION("fromUtf32()")
{ {
constexpr std::array<std::uint32_t, 4> characters{'w', 0x104321, 'y', 'z'}; constexpr std::array<std::uint32_t, 4> characters{'w', 0x104321, 'y', 'z'};
const sf::String string = sf::String::fromUtf32(characters.begin(), characters.end()); const sf::String string = sf::String::fromUtf32(characters.begin(), characters.end());
@ -289,7 +283,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getData() != nullptr); CHECK(string.getData() != nullptr);
} }
SUBCASE("clear()") SECTION("clear()")
{ {
sf::String string("you'll never guess what happens when you call clear()"); sf::String string("you'll never guess what happens when you call clear()");
string.clear(); string.clear();
@ -297,7 +291,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getSize() == 0); CHECK(string.getSize() == 0);
} }
SUBCASE("erase()") SECTION("erase()")
{ {
sf::String string("what if i want a shorter string?"); sf::String string("what if i want a shorter string?");
string.erase(0, 8); string.erase(0, 8);
@ -306,7 +300,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getSize() == 23); CHECK(string.getSize() == 23);
} }
SUBCASE("insert()") SECTION("insert()")
{ {
sf::String string("please insert text"); sf::String string("please insert text");
string.insert(7, "don't "); string.insert(7, "don't ");
@ -314,7 +308,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.getSize() == 24); CHECK(string.getSize() == 24);
} }
SUBCASE("find()") SECTION("find()")
{ {
const sf::String string("a little bit of this and a little bit of that"); const sf::String string("a little bit of this and a little bit of that");
CHECK(string.find("a little bit") == 0); CHECK(string.find("a little bit") == 0);
@ -323,7 +317,7 @@ TEST_CASE("[System] sf::String")
CHECK(string.find("no way you find this") == sf::String::InvalidPos); CHECK(string.find("no way you find this") == sf::String::InvalidPos);
} }
SUBCASE("replace()") SECTION("replace()")
{ {
sf::String string("sfml is the worst"); sf::String string("sfml is the worst");
string.replace(12, 5, "best!"); string.replace(12, 5, "best!");
@ -332,7 +326,7 @@ TEST_CASE("[System] sf::String")
CHECK(string == "sfml is THE best!"); CHECK(string == "sfml is THE best!");
} }
SUBCASE("substring()") SECTION("substring()")
{ {
const sf::String string("let's get some substrings"); const sf::String string("let's get some substrings");
CHECK(string.substring(0) == "let's get some substrings"); CHECK(string.substring(0) == "let's get some substrings");
@ -342,7 +336,7 @@ TEST_CASE("[System] sf::String")
CHECK_THROWS_AS((void)string.substring(420, 69), std::out_of_range); CHECK_THROWS_AS((void)string.substring(420, 69), std::out_of_range);
} }
SUBCASE("begin() and end() const") SECTION("begin() and end() const")
{ {
const sf::String string("let's test the const iterators"); const sf::String string("let's test the const iterators");
CHECK(*string.begin() == 'l'); CHECK(*string.begin() == 'l');
@ -351,7 +345,7 @@ TEST_CASE("[System] sf::String")
CHECK(character != 0); CHECK(character != 0);
} }
SUBCASE("begin() and end()") SECTION("begin() and end()")
{ {
sf::String string("let's test the iterators"); sf::String string("let's test the iterators");
CHECK(*string.begin() == 'l'); CHECK(*string.begin() == 'l');
@ -361,23 +355,23 @@ TEST_CASE("[System] sf::String")
CHECK(string == "xxxxxxxxxxxxxxxxxxxxxxxx"); CHECK(string == "xxxxxxxxxxxxxxxxxxxxxxxx");
} }
SUBCASE("Operators") SECTION("Operators")
{ {
SUBCASE("operator+=") SECTION("operator+=")
{ {
sf::String string; sf::String string;
string += sf::String("xyz"); string += sf::String("xyz");
CHECK(string.toAnsiString() == "xyz"s); CHECK(string.toAnsiString() == "xyz"s);
} }
SUBCASE("operator[] const") SECTION("operator[] const")
{ {
const sf::String string("the quick brown fox"); const sf::String string("the quick brown fox");
CHECK(string[0] == 't'); CHECK(string[0] == 't');
CHECK(string[10] == 'b'); CHECK(string[10] == 'b');
} }
SUBCASE("operator[]") SECTION("operator[]")
{ {
sf::String string("the quick brown fox"); sf::String string("the quick brown fox");
CHECK(string[0] == 't'); CHECK(string[0] == 't');
@ -385,43 +379,43 @@ TEST_CASE("[System] sf::String")
CHECK(string[1] == 'x'); CHECK(string[1] == 'x');
} }
SUBCASE("operator==") SECTION("operator==")
{ {
CHECK(sf::String() == sf::String()); CHECK(sf::String() == sf::String());
CHECK_FALSE(sf::String() == sf::String(' ')); CHECK_FALSE(sf::String() == sf::String(' '));
} }
SUBCASE("operator!=") SECTION("operator!=")
{ {
CHECK(sf::String() != sf::String(' ')); CHECK(sf::String() != sf::String(' '));
CHECK_FALSE(sf::String() != sf::String()); CHECK_FALSE(sf::String() != sf::String());
} }
SUBCASE("operator<") SECTION("operator<")
{ {
CHECK(sf::String('a') < sf::String('b')); CHECK(sf::String('a') < sf::String('b'));
CHECK_FALSE(sf::String() < sf::String()); CHECK_FALSE(sf::String() < sf::String());
} }
SUBCASE("operator>") SECTION("operator>")
{ {
CHECK(sf::String('b') > sf::String('a')); CHECK(sf::String('b') > sf::String('a'));
CHECK_FALSE(sf::String() > sf::String()); CHECK_FALSE(sf::String() > sf::String());
} }
SUBCASE("operator<=") SECTION("operator<=")
{ {
CHECK(sf::String() <= sf::String()); CHECK(sf::String() <= sf::String());
CHECK(sf::String('a') <= sf::String('b')); CHECK(sf::String('a') <= sf::String('b'));
} }
SUBCASE("operator>=") SECTION("operator>=")
{ {
CHECK(sf::String() >= sf::String()); CHECK(sf::String() >= sf::String());
CHECK(sf::String('b') >= sf::String('a')); CHECK(sf::String('b') >= sf::String('a'));
} }
SUBCASE("operator+") SECTION("operator+")
{ {
CHECK(sf::String() + sf::String() == sf::String()); CHECK(sf::String() + sf::String() == sf::String());
CHECK(sf::String("abc") + sf::String("def") == sf::String("abcdef")); CHECK(sf::String("abc") + sf::String("def") == sf::String("abcdef"));

325
test/System/Time.test.cpp
View File

@ -1,257 +1,246 @@
#include <SFML/System/Time.hpp> #include <SFML/System/Time.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <SystemUtil.hpp> #include <SystemUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::Time>);
static_assert(std::is_copy_assignable_v<sf::Time>);
static_assert(std::is_nothrow_move_constructible_v<sf::Time>);
static_assert(std::is_nothrow_move_assignable_v<sf::Time>);
using namespace std::chrono_literals; using namespace std::chrono_literals;
// Specialize StringMaker for std::chrono::duration specializations
// https://github.com/doctest/doctest/blob/master/doc/markdown/stringification.md#docteststringmakert-specialisation
namespace doctest
{
template <typename Rep, typename Period>
struct StringMaker<std::chrono::duration<Rep, Period>>
{
static String convert(const std::chrono::duration<Rep, Period>& duration)
{
return toString(std::chrono::microseconds(duration).count()) + "us";
}
};
} // namespace doctest
TEST_CASE("[System] sf::Time") TEST_CASE("[System] sf::Time")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::Time>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Time>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Time>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Time>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::Time time; constexpr sf::Time time;
CHECK(time.asSeconds() == 0.0f); STATIC_CHECK(time.asSeconds() == 0.0f);
CHECK(time.asMilliseconds() == 0); STATIC_CHECK(time.asMilliseconds() == 0);
CHECK(time.asMicroseconds() == 0); STATIC_CHECK(time.asMicroseconds() == 0);
} }
SUBCASE("Construct from seconds") SECTION("Construct from seconds")
{ {
const sf::Time time = sf::seconds(123); constexpr sf::Time time = sf::seconds(123);
CHECK(time.asSeconds() == 123.0f); STATIC_CHECK(time.asSeconds() == 123.0f);
CHECK(time.asMilliseconds() == 123'000); STATIC_CHECK(time.asMilliseconds() == 123'000);
CHECK(time.asMicroseconds() == 123'000'000); STATIC_CHECK(time.asMicroseconds() == 123'000'000);
CHECK(sf::seconds(1'000.0f).asMicroseconds() == 1'000'000'000); STATIC_CHECK(sf::seconds(1'000.0f).asMicroseconds() == 1'000'000'000);
CHECK(sf::seconds(0.0000009f).asMicroseconds() == 0); STATIC_CHECK(sf::seconds(0.0000009f).asMicroseconds() == 0);
CHECK(sf::seconds(0.0000001f).asMicroseconds() == 0); STATIC_CHECK(sf::seconds(0.0000001f).asMicroseconds() == 0);
CHECK(sf::seconds(0.00000001f).asMicroseconds() == 0); STATIC_CHECK(sf::seconds(0.00000001f).asMicroseconds() == 0);
CHECK(sf::seconds(0.000000001f).asMicroseconds() == 0); STATIC_CHECK(sf::seconds(0.000000001f).asMicroseconds() == 0);
CHECK(sf::seconds(-0.000000001f).asMicroseconds() == 0); STATIC_CHECK(sf::seconds(-0.000000001f).asMicroseconds() == 0);
CHECK(sf::seconds(-0.00000001f).asMicroseconds() == 0); STATIC_CHECK(sf::seconds(-0.00000001f).asMicroseconds() == 0);
CHECK(sf::seconds(-0.0000001f).asMicroseconds() == 0); STATIC_CHECK(sf::seconds(-0.0000001f).asMicroseconds() == 0);
CHECK(sf::seconds(-0.0000009f).asMicroseconds() == 0); STATIC_CHECK(sf::seconds(-0.0000009f).asMicroseconds() == 0);
CHECK(sf::seconds(-1'000.0f).asMicroseconds() == -1'000'000'000); STATIC_CHECK(sf::seconds(-1'000.0f).asMicroseconds() == -1'000'000'000);
} }
SUBCASE("Construct from milliseconds") SECTION("Construct from milliseconds")
{ {
const sf::Time time = sf::milliseconds(42); constexpr sf::Time time = sf::milliseconds(42);
CHECK(time.asSeconds() == 0.042f); STATIC_CHECK(time.asSeconds() == 0.042f);
CHECK(time.asMilliseconds() == 42); STATIC_CHECK(time.asMilliseconds() == 42);
CHECK(time.asMicroseconds() == 42'000); STATIC_CHECK(time.asMicroseconds() == 42'000);
} }
SUBCASE("Construct from microseconds") SECTION("Construct from microseconds")
{ {
const sf::Time time = sf::microseconds(987654); constexpr sf::Time time = sf::microseconds(987654);
CHECK(time.asSeconds() == 0.987654f); STATIC_CHECK(time.asSeconds() == 0.987654f);
CHECK(time.asMilliseconds() == 987); STATIC_CHECK(time.asMilliseconds() == 987);
CHECK(time.asMicroseconds() == 987'654); STATIC_CHECK(time.asMicroseconds() == 987'654);
} }
SUBCASE("Convert from chrono duration") SECTION("Convert from chrono duration")
{ {
{ {
const sf::Time time = 3min; constexpr sf::Time time = 3min;
CHECK(time.asSeconds() == 180.f); STATIC_CHECK(time.asSeconds() == 180.f);
CHECK(time.asMilliseconds() == 180'000); STATIC_CHECK(time.asMilliseconds() == 180'000);
CHECK(time.asMicroseconds() == 180'000'000); STATIC_CHECK(time.asMicroseconds() == 180'000'000);
} }
{ {
const sf::Time time = 1s; constexpr sf::Time time = 1s;
CHECK(time.asSeconds() == 1.f); STATIC_CHECK(time.asSeconds() == 1.f);
CHECK(time.asMilliseconds() == 1'000); STATIC_CHECK(time.asMilliseconds() == 1'000);
CHECK(time.asMicroseconds() == 1'000'000); STATIC_CHECK(time.asMicroseconds() == 1'000'000);
} }
{ {
const sf::Time time = 10ms; constexpr sf::Time time = 10ms;
CHECK(time.asSeconds() == 0.01f); STATIC_CHECK(time.asSeconds() == 0.01f);
CHECK(time.asMilliseconds() == 10); STATIC_CHECK(time.asMilliseconds() == 10);
CHECK(time.asMicroseconds() == 10'000); STATIC_CHECK(time.asMicroseconds() == 10'000);
} }
{ {
const sf::Time time = 2048us; constexpr sf::Time time = 2048us;
CHECK(time.asSeconds() == 0.002048f); STATIC_CHECK(time.asSeconds() == 0.002048f);
CHECK(time.asMilliseconds() == 2); STATIC_CHECK(time.asMilliseconds() == 2);
CHECK(time.asMicroseconds() == 2048); STATIC_CHECK(time.asMicroseconds() == 2048);
} }
} }
} }
SUBCASE("toDuration()") SECTION("toDuration()")
{ {
CHECK(sf::seconds(0).toDuration() == 0s); STATIC_CHECK(sf::seconds(0).toDuration() == 0s);
CHECK(sf::milliseconds(0).toDuration() == 0ms); STATIC_CHECK(sf::milliseconds(0).toDuration() == 0ms);
CHECK(sf::microseconds(0).toDuration() == 0us); STATIC_CHECK(sf::microseconds(0).toDuration() == 0us);
CHECK(sf::seconds(-1).toDuration() == -1s); STATIC_CHECK(sf::seconds(-1).toDuration() == -1s);
CHECK(sf::milliseconds(-1).toDuration() == -1ms); STATIC_CHECK(sf::milliseconds(-1).toDuration() == -1ms);
CHECK(sf::microseconds(-1).toDuration() == -1us); STATIC_CHECK(sf::microseconds(-1).toDuration() == -1us);
CHECK(sf::seconds(1).toDuration() == 1s); STATIC_CHECK(sf::seconds(1).toDuration() == 1s);
CHECK(sf::milliseconds(1).toDuration() == 1ms); STATIC_CHECK(sf::milliseconds(1).toDuration() == 1ms);
CHECK(sf::microseconds(1).toDuration() == 1us); STATIC_CHECK(sf::microseconds(1).toDuration() == 1us);
CHECK(sf::seconds(-10).toDuration() == -10s); STATIC_CHECK(sf::seconds(-10).toDuration() == -10s);
CHECK(sf::milliseconds(-10).toDuration() == -10ms); STATIC_CHECK(sf::milliseconds(-10).toDuration() == -10ms);
CHECK(sf::microseconds(-10).toDuration() == -10us); STATIC_CHECK(sf::microseconds(-10).toDuration() == -10us);
CHECK(sf::seconds(10).toDuration() == 10s); STATIC_CHECK(sf::seconds(10).toDuration() == 10s);
CHECK(sf::milliseconds(10).toDuration() == 10ms); STATIC_CHECK(sf::milliseconds(10).toDuration() == 10ms);
CHECK(sf::microseconds(10).toDuration() == 10us); STATIC_CHECK(sf::microseconds(10).toDuration() == 10us);
CHECK(sf::Time(1s).toDuration() == 1s); STATIC_CHECK(sf::Time(1s).toDuration() == 1s);
CHECK(sf::Time(1ms).toDuration() == 1ms); STATIC_CHECK(sf::Time(1ms).toDuration() == 1ms);
CHECK(sf::Time(1us).toDuration() == 1us); STATIC_CHECK(sf::Time(1us).toDuration() == 1us);
} }
SUBCASE("Implicit conversion to duration") SECTION("Implicit conversion to duration")
{ {
const auto toDuration = [](const std::chrono::microseconds& duration) { return duration; }; const auto toDuration = [](const std::chrono::microseconds& duration) { return duration; };
CHECK(toDuration(sf::seconds(0)) == 0s); STATIC_CHECK(toDuration(sf::seconds(0)) == 0s);
CHECK(toDuration(sf::milliseconds(0)) == 0ms); STATIC_CHECK(toDuration(sf::milliseconds(0)) == 0ms);
CHECK(toDuration(sf::microseconds(0)) == 0us); STATIC_CHECK(toDuration(sf::microseconds(0)) == 0us);
CHECK(toDuration(sf::seconds(-1)) == -1s); STATIC_CHECK(toDuration(sf::seconds(-1)) == -1s);
CHECK(toDuration(sf::milliseconds(-1)) == -1ms); STATIC_CHECK(toDuration(sf::milliseconds(-1)) == -1ms);
CHECK(toDuration(sf::microseconds(-1)) == -1us); STATIC_CHECK(toDuration(sf::microseconds(-1)) == -1us);
CHECK(toDuration(sf::seconds(1)) == 1s); STATIC_CHECK(toDuration(sf::seconds(1)) == 1s);
CHECK(toDuration(sf::milliseconds(1)) == 1ms); STATIC_CHECK(toDuration(sf::milliseconds(1)) == 1ms);
CHECK(toDuration(sf::microseconds(1)) == 1us); STATIC_CHECK(toDuration(sf::microseconds(1)) == 1us);
CHECK(toDuration(sf::seconds(-10)) == -10s); STATIC_CHECK(toDuration(sf::seconds(-10)) == -10s);
CHECK(toDuration(sf::milliseconds(-10)) == -10ms); STATIC_CHECK(toDuration(sf::milliseconds(-10)) == -10ms);
CHECK(toDuration(sf::microseconds(-10)) == -10us); STATIC_CHECK(toDuration(sf::microseconds(-10)) == -10us);
CHECK(toDuration(sf::seconds(10)) == 10s); STATIC_CHECK(toDuration(sf::seconds(10)) == 10s);
CHECK(toDuration(sf::milliseconds(10)) == 10ms); STATIC_CHECK(toDuration(sf::milliseconds(10)) == 10ms);
CHECK(toDuration(sf::microseconds(10)) == 10us); STATIC_CHECK(toDuration(sf::microseconds(10)) == 10us);
CHECK(toDuration(sf::Time(1s)) == 1s); STATIC_CHECK(toDuration(sf::Time(1s)) == 1s);
CHECK(toDuration(sf::Time(1ms)) == 1ms); STATIC_CHECK(toDuration(sf::Time(1ms)) == 1ms);
CHECK(toDuration(sf::Time(1us)) == 1us); STATIC_CHECK(toDuration(sf::Time(1us)) == 1us);
} }
SUBCASE("Zero time") SECTION("Zero time")
{ {
CHECK(sf::Time::Zero.asSeconds() == 0.0f); STATIC_CHECK(sf::Time::Zero.asSeconds() == 0.0f);
CHECK(sf::Time::Zero.asMilliseconds() == 0); STATIC_CHECK(sf::Time::Zero.asMilliseconds() == 0);
CHECK(sf::Time::Zero.asMicroseconds() == 0); STATIC_CHECK(sf::Time::Zero.asMicroseconds() == 0);
} }
SUBCASE("Operators") SECTION("Operators")
{ {
SUBCASE("operator==") SECTION("operator==")
{ {
CHECK(sf::Time() == sf::Time()); STATIC_CHECK(sf::Time() == sf::Time());
CHECK(sf::seconds(1) == sf::seconds(1)); STATIC_CHECK(sf::seconds(1) == sf::seconds(1));
CHECK(sf::seconds(10) == sf::milliseconds(10'000)); STATIC_CHECK(sf::seconds(10) == sf::milliseconds(10'000));
CHECK(sf::milliseconds(450'450) == sf::microseconds(450'450'000)); STATIC_CHECK(sf::milliseconds(450'450) == sf::microseconds(450'450'000));
CHECK(sf::seconds(0.5f) == sf::microseconds(500'000)); STATIC_CHECK(sf::seconds(0.5f) == sf::microseconds(500'000));
} }
SUBCASE("operator!=") SECTION("operator!=")
{ {
CHECK(sf::seconds(10.12f) != sf::milliseconds(10'121)); STATIC_CHECK(sf::seconds(10.12f) != sf::milliseconds(10'121));
CHECK(sf::microseconds(123'456) != sf::milliseconds(123)); STATIC_CHECK(sf::microseconds(123'456) != sf::milliseconds(123));
} }
SUBCASE("operator<") SECTION("operator<")
{ {
CHECK(sf::seconds(54.999f) < sf::seconds(55)); STATIC_CHECK(sf::seconds(54.999f) < sf::seconds(55));
CHECK(sf::microseconds(10) < sf::milliseconds(10)); STATIC_CHECK(sf::microseconds(10) < sf::milliseconds(10));
CHECK(sf::milliseconds(1'000) < sf::microseconds(1'000'001)); STATIC_CHECK(sf::milliseconds(1'000) < sf::microseconds(1'000'001));
} }
SUBCASE("operator>") SECTION("operator>")
{ {
CHECK(sf::seconds(55.001f) > sf::seconds(55)); STATIC_CHECK(sf::seconds(55.001f) > sf::seconds(55));
CHECK(sf::microseconds(1) > sf::seconds(0.0000001f)); STATIC_CHECK(sf::microseconds(1) > sf::seconds(0.0000001f));
CHECK(sf::microseconds(1'000'001) > sf::milliseconds(1'000)); STATIC_CHECK(sf::microseconds(1'000'001) > sf::milliseconds(1'000));
} }
SUBCASE("operator<=") SECTION("operator<=")
{ {
CHECK(sf::milliseconds(100) <= sf::milliseconds(100)); STATIC_CHECK(sf::milliseconds(100) <= sf::milliseconds(100));
CHECK(sf::seconds(0.0012f) <= sf::microseconds(1'201)); STATIC_CHECK(sf::seconds(0.0012f) <= sf::microseconds(1'201));
} }
SUBCASE("operator>=") SECTION("operator>=")
{ {
CHECK(sf::milliseconds(100) >= sf::milliseconds(-100)); STATIC_CHECK(sf::milliseconds(100) >= sf::milliseconds(-100));
CHECK(sf::microseconds(1'201) >= sf::seconds(0.0012f)); STATIC_CHECK(sf::microseconds(1'201) >= sf::seconds(0.0012f));
} }
SUBCASE("operator-") SECTION("operator-")
{ {
CHECK(sf::seconds(-1) == -sf::seconds(1)); STATIC_CHECK(sf::seconds(-1) == -sf::seconds(1));
CHECK(sf::microseconds(1'234) == -sf::microseconds(-1'234)); STATIC_CHECK(sf::microseconds(1'234) == -sf::microseconds(-1'234));
} }
SUBCASE("operator+") SECTION("operator+")
{ {
CHECK(sf::seconds(1) + sf::seconds(1) == sf::seconds(2)); STATIC_CHECK(sf::seconds(1) + sf::seconds(1) == sf::seconds(2));
CHECK(sf::milliseconds(400) + sf::microseconds(400) == sf::microseconds(400400)); STATIC_CHECK(sf::milliseconds(400) + sf::microseconds(400) == sf::microseconds(400400));
} }
SUBCASE("operator+=") SECTION("operator+=")
{ {
sf::Time time = sf::seconds(1.5f); sf::Time time = sf::seconds(1.5f);
time += sf::seconds(1); time += sf::seconds(1);
CHECK(time == sf::seconds(2.5f)); CHECK(time == sf::seconds(2.5f));
} }
SUBCASE("operator-") SECTION("operator-")
{ {
CHECK(sf::seconds(1) - sf::seconds(1) == sf::seconds(0)); STATIC_CHECK(sf::seconds(1) - sf::seconds(1) == sf::seconds(0));
CHECK(sf::milliseconds(400) - sf::microseconds(400) == sf::microseconds(399600)); STATIC_CHECK(sf::milliseconds(400) - sf::microseconds(400) == sf::microseconds(399600));
} }
SUBCASE("operator-=") SECTION("operator-=")
{ {
sf::Time time = sf::seconds(1.5f); sf::Time time = sf::seconds(1.5f);
time -= sf::seconds(10); time -= sf::seconds(10);
CHECK(time == sf::seconds(-8.5f)); CHECK(time == sf::seconds(-8.5f));
} }
SUBCASE("operator*") SECTION("operator*")
{ {
CHECK(sf::seconds(1) * 2.0f == sf::seconds(2)); STATIC_CHECK(sf::seconds(1) * 2.0f == sf::seconds(2));
CHECK(sf::seconds(12) * 0.5f == sf::seconds(6)); STATIC_CHECK(sf::seconds(12) * 0.5f == sf::seconds(6));
CHECK(sf::seconds(1) * static_cast<std::int64_t>(2) == sf::seconds(2)); STATIC_CHECK(sf::seconds(1) * std::int64_t{2} == sf::seconds(2));
CHECK(sf::seconds(42) * static_cast<std::int64_t>(2) == sf::seconds(84)); STATIC_CHECK(sf::seconds(42) * std::int64_t{2} == sf::seconds(84));
CHECK(2.0f * sf::seconds(1) == sf::seconds(2)); STATIC_CHECK(2.0f * sf::seconds(1) == sf::seconds(2));
CHECK(0.5f * sf::seconds(12) == sf::seconds(6)); STATIC_CHECK(0.5f * sf::seconds(12) == sf::seconds(6));
CHECK(static_cast<std::int64_t>(2) * sf::seconds(1) == sf::seconds(2)); STATIC_CHECK(std::int64_t{2} * sf::seconds(1) == sf::seconds(2));
CHECK(static_cast<std::int64_t>(2) * sf::seconds(42) == sf::seconds(84)); STATIC_CHECK(std::int64_t{2} * sf::seconds(42) == sf::seconds(84));
} }
SUBCASE("operator*=") SECTION("operator*=")
{ {
sf::Time time = sf::milliseconds(1'000); sf::Time time = sf::milliseconds(1'000);
time *= static_cast<std::int64_t>(10); time *= static_cast<std::int64_t>(10);
@ -260,17 +249,17 @@ TEST_CASE("[System] sf::Time")
CHECK(time.asMilliseconds() == 1'000); CHECK(time.asMilliseconds() == 1'000);
} }
SUBCASE("operator/") SECTION("operator/")
{ {
CHECK(sf::seconds(1) / 2.0f == sf::seconds(0.5f)); STATIC_CHECK(sf::seconds(1) / 2.0f == sf::seconds(0.5f));
CHECK(sf::seconds(12) / 0.5f == sf::seconds(24)); STATIC_CHECK(sf::seconds(12) / 0.5f == sf::seconds(24));
CHECK(sf::seconds(1) / static_cast<std::int64_t>(2) == sf::seconds(0.5f)); STATIC_CHECK(sf::seconds(1) / std::int64_t{2} == sf::seconds(0.5f));
CHECK(sf::seconds(42) / static_cast<std::int64_t>(2) == sf::seconds(21)); STATIC_CHECK(sf::seconds(42) / std::int64_t{2} == sf::seconds(21));
CHECK(sf::seconds(1) / sf::seconds(1) == 1.0f); STATIC_CHECK(sf::seconds(1) / sf::seconds(1) == 1.0f);
CHECK(sf::milliseconds(10) / sf::microseconds(1) == Approx(10'000.f)); CHECK(sf::milliseconds(10) / sf::microseconds(1) == Approx(10'000.f));
} }
SUBCASE("operator/=") SECTION("operator/=")
{ {
sf::Time time = sf::milliseconds(1'000); sf::Time time = sf::milliseconds(1'000);
time /= static_cast<std::int64_t>(2); time /= static_cast<std::int64_t>(2);
@ -279,13 +268,13 @@ TEST_CASE("[System] sf::Time")
CHECK(time.asMilliseconds() == 1'000); CHECK(time.asMilliseconds() == 1'000);
} }
SUBCASE("operator%") SECTION("operator%")
{ {
CHECK(sf::seconds(10) % sf::seconds(3) == sf::seconds(1)); STATIC_CHECK(sf::seconds(10) % sf::seconds(3) == sf::seconds(1));
CHECK(sf::milliseconds(100) % sf::microseconds(10) == sf::seconds(0)); STATIC_CHECK(sf::milliseconds(100) % sf::microseconds(10) == sf::seconds(0));
} }
SUBCASE("operator%=") SECTION("operator%=")
{ {
sf::Time time = sf::milliseconds(100); sf::Time time = sf::milliseconds(100);
time %= sf::milliseconds(99); time %= sf::milliseconds(99);
@ -293,7 +282,7 @@ TEST_CASE("[System] sf::Time")
} }
} }
SUBCASE("Constexpr support") SECTION("Constexpr support")
{ {
constexpr auto result = [] constexpr auto result = []
{ {
@ -302,6 +291,6 @@ TEST_CASE("[System] sf::Time")
return time; return time;
}(); }();
static_assert(result == sf::milliseconds(1)); STATIC_CHECK(result == sf::milliseconds(1));
} }
} }

167
test/System/Vector2.test.cpp
View File

@ -1,6 +1,6 @@
#include <SFML/System/Vector2.hpp> #include <SFML/System/Vector2.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <SystemUtil.hpp> #include <SystemUtil.hpp>
#include <type_traits> #include <type_traits>
@ -12,39 +12,42 @@ using namespace sf::Literals;
// Use sf::Vector2i for tests (except for float vector algebra). // Use sf::Vector2i for tests (except for float vector algebra).
// Test coverage is given, as there are no template specializations. // Test coverage is given, as there are no template specializations.
static_assert(std::is_copy_constructible_v<sf::Vector2i>);
static_assert(std::is_copy_assignable_v<sf::Vector2i>);
static_assert(std::is_nothrow_move_constructible_v<sf::Vector2i>);
static_assert(std::is_nothrow_move_assignable_v<sf::Vector2i>);
TEST_CASE("[System] sf::Vector2") TEST_CASE("[System] sf::Vector2")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::Vector2i>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Vector2i>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Vector2i>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Vector2i>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::Vector2i vector; constexpr sf::Vector2i vector;
CHECK(vector.x == 0); STATIC_CHECK(vector.x == 0);
CHECK(vector.y == 0); STATIC_CHECK(vector.y == 0);
} }
SUBCASE("(x, y) coordinate constructor") SECTION("(x, y) coordinate constructor")
{ {
const sf::Vector2i vector(1, 2); constexpr sf::Vector2i vector(1, 2);
CHECK(vector.x == 1); STATIC_CHECK(vector.x == 1);
CHECK(vector.y == 2); STATIC_CHECK(vector.y == 2);
} }
SUBCASE("Conversion constructor") SECTION("Conversion constructor")
{ {
const sf::Vector2f sourceVector(1.0f, 2.0f); constexpr sf::Vector2f sourceVector(1.0f, 2.0f);
const sf::Vector2i vector(sourceVector); constexpr sf::Vector2i vector(sourceVector);
CHECK(vector.x == static_cast<int>(sourceVector.x)); STATIC_CHECK(vector.x == static_cast<int>(sourceVector.x));
CHECK(vector.y == static_cast<int>(sourceVector.y)); STATIC_CHECK(vector.y == static_cast<int>(sourceVector.y));
} }
SUBCASE("Length and angle constructor") SECTION("Length and angle constructor")
{ {
CHECK(sf::Vector2f(0, 0_deg) == sf::Vector2f(0, 0)); CHECK(sf::Vector2f(0, 0_deg) == sf::Vector2f(0, 0));
CHECK(sf::Vector2f(0, 45_deg) == sf::Vector2f(0, 0)); CHECK(sf::Vector2f(0, 45_deg) == sf::Vector2f(0, 0));
@ -98,24 +101,24 @@ TEST_CASE("[System] sf::Vector2")
} }
} }
SUBCASE("Unary operations") SECTION("Unary operations")
{ {
SUBCASE("-vector") SECTION("-vector")
{ {
const sf::Vector2i vector(1, 2); constexpr sf::Vector2i vector(1, 2);
const sf::Vector2i negatedVector = -vector; constexpr sf::Vector2i negatedVector = -vector;
CHECK(negatedVector.x == -1); STATIC_CHECK(negatedVector.x == -1);
CHECK(negatedVector.y == -2); STATIC_CHECK(negatedVector.y == -2);
} }
} }
SUBCASE("Arithmetic operations between two vectors") SECTION("Arithmetic operations between two vectors")
{ {
sf::Vector2i firstVector(2, 5); sf::Vector2i firstVector(2, 5);
const sf::Vector2i secondVector(8, 3); constexpr sf::Vector2i secondVector(8, 3);
SUBCASE("vector += vector") SECTION("vector += vector")
{ {
firstVector += secondVector; firstVector += secondVector;
@ -123,7 +126,7 @@ TEST_CASE("[System] sf::Vector2")
CHECK(firstVector.y == 8); CHECK(firstVector.y == 8);
} }
SUBCASE("vector -= vector") SECTION("vector -= vector")
{ {
firstVector -= secondVector; firstVector -= secondVector;
@ -131,7 +134,7 @@ TEST_CASE("[System] sf::Vector2")
CHECK(firstVector.y == 2); CHECK(firstVector.y == 2);
} }
SUBCASE("vector + vector") SECTION("vector + vector")
{ {
const sf::Vector2i result = firstVector + secondVector; const sf::Vector2i result = firstVector + secondVector;
@ -139,7 +142,7 @@ TEST_CASE("[System] sf::Vector2")
CHECK(result.y == 8); CHECK(result.y == 8);
} }
SUBCASE("vector - vector") SECTION("vector - vector")
{ {
const sf::Vector2i result = firstVector - secondVector; const sf::Vector2i result = firstVector - secondVector;
@ -148,12 +151,12 @@ TEST_CASE("[System] sf::Vector2")
} }
} }
SUBCASE("Arithmetic operations between vector and scalar value") SECTION("Arithmetic operations between vector and scalar value")
{ {
sf::Vector2i vector(26, 12); sf::Vector2i vector(26, 12);
const int scalar = 2; const int scalar = 2;
SUBCASE("vector * scalar") SECTION("vector * scalar")
{ {
const sf::Vector2i result = vector * scalar; const sf::Vector2i result = vector * scalar;
@ -161,7 +164,7 @@ TEST_CASE("[System] sf::Vector2")
CHECK(result.y == 24); CHECK(result.y == 24);
} }
SUBCASE("scalar * vector") SECTION("scalar * vector")
{ {
const sf::Vector2i result = scalar * vector; const sf::Vector2i result = scalar * vector;
@ -169,7 +172,7 @@ TEST_CASE("[System] sf::Vector2")
CHECK(result.y == 24); CHECK(result.y == 24);
} }
SUBCASE("vector *= scalar") SECTION("vector *= scalar")
{ {
vector *= scalar; vector *= scalar;
@ -177,7 +180,7 @@ TEST_CASE("[System] sf::Vector2")
CHECK(vector.y == 24); CHECK(vector.y == 24);
} }
SUBCASE("vector / scalar") SECTION("vector / scalar")
{ {
const sf::Vector2i result = vector / scalar; const sf::Vector2i result = vector / scalar;
@ -185,7 +188,7 @@ TEST_CASE("[System] sf::Vector2")
CHECK(result.y == 6); CHECK(result.y == 6);
} }
SUBCASE("vector /= scalar") SECTION("vector /= scalar")
{ {
vector /= scalar; vector /= scalar;
@ -194,37 +197,37 @@ TEST_CASE("[System] sf::Vector2")
} }
} }
SUBCASE("Comparison operations (two equal and one different vector)") SECTION("Comparison operations (two equal and one different vector)")
{ {
const sf::Vector2i firstEqualVector(1, 5); constexpr sf::Vector2i firstEqualVector(1, 5);
const sf::Vector2i secondEqualVector(1, 5); constexpr sf::Vector2i secondEqualVector(1, 5);
const sf::Vector2i differentVector(6, 9); constexpr sf::Vector2i differentVector(6, 9);
SUBCASE("vector == vector") SECTION("vector == vector")
{ {
CHECK(firstEqualVector == secondEqualVector); STATIC_CHECK(firstEqualVector == secondEqualVector);
CHECK_FALSE(firstEqualVector == differentVector); STATIC_CHECK_FALSE(firstEqualVector == differentVector);
} }
SUBCASE("vector != vector") SECTION("vector != vector")
{ {
CHECK(firstEqualVector != differentVector); STATIC_CHECK(firstEqualVector != differentVector);
CHECK_FALSE(firstEqualVector != secondEqualVector); STATIC_CHECK_FALSE(firstEqualVector != secondEqualVector);
} }
} }
SUBCASE("Structured bindings") SECTION("Structured bindings")
{ {
sf::Vector2i vector(1, 2); sf::Vector2i vector(1, 2); // NOLINT(misc-const-correctness)
SUBCASE("destructure by value") SECTION("destructure by value")
{ {
auto [x, y] = vector; auto [x, y] = vector;
CHECK(x == 1); CHECK(x == 1);
CHECK(y == 2); CHECK(y == 2);
static_assert(std::is_same_v<decltype(x), decltype(vector.x)>); STATIC_CHECK(std::is_same_v<decltype(x), decltype(vector.x)>);
x = 3; x = 3;
@ -232,14 +235,14 @@ TEST_CASE("[System] sf::Vector2")
CHECK(vector.x == 1); CHECK(vector.x == 1);
} }
SUBCASE("destructure by ref") SECTION("destructure by ref")
{ {
auto& [x, y] = vector; auto& [x, y] = vector;
CHECK(x == 1); CHECK(x == 1);
CHECK(y == 2); CHECK(y == 2);
static_assert(std::is_same_v<decltype(x), decltype(vector.x)>); STATIC_CHECK(std::is_same_v<decltype(x), decltype(vector.x)>);
x = 3; x = 3;
@ -248,30 +251,30 @@ TEST_CASE("[System] sf::Vector2")
} }
} }
SUBCASE("Length and normalization") SECTION("Length and normalization")
{ {
const sf::Vector2f v(2.4f, 3.0f); constexpr sf::Vector2f v(2.4f, 3.0f);
CHECK(v.length() == Approx(3.84187f)); CHECK(v.length() == Approx(3.84187f));
CHECK(v.lengthSq() == Approx(14.7599650969f)); CHECK(v.lengthSq() == Approx(14.7599650969f));
CHECK(v.normalized() == Approx(sf::Vector2f(0.624695f, 0.780869f))); CHECK(v.normalized() == Approx(sf::Vector2f(0.624695f, 0.780869f)));
const sf::Vector2f w(-0.7f, -2.2f); constexpr sf::Vector2f w(-0.7f, -2.2f);
CHECK(w.length() == Approx(2.30868f)); CHECK(w.length() == Approx(2.30868f));
CHECK(w.lengthSq() == Approx(5.3300033f)); CHECK(w.lengthSq() == Approx(5.3300033f));
CHECK(w.normalized() == Approx(sf::Vector2f(-0.303204f, -0.952926f))); CHECK(w.normalized() == Approx(sf::Vector2f(-0.303204f, -0.952926f)));
} }
SUBCASE("Rotations and angles") SECTION("Rotations and angles")
{ {
const sf::Vector2f v(2.4f, 3.0f); constexpr sf::Vector2f v(2.4f, 3.0f);
CHECK(v.angle() == Approx(51.3402_deg)); CHECK(v.angle() == Approx(51.3402_deg));
CHECK(sf::Vector2f::UnitX.angleTo(v) == Approx(51.3402_deg)); CHECK(sf::Vector2f::UnitX.angleTo(v) == Approx(51.3402_deg));
CHECK(sf::Vector2f::UnitY.angleTo(v) == Approx(-38.6598_deg)); CHECK(sf::Vector2f::UnitY.angleTo(v) == Approx(-38.6598_deg));
const sf::Vector2f w(-0.7f, -2.2f); constexpr sf::Vector2f w(-0.7f, -2.2f);
CHECK(w.angle() == Approx(-107.65_deg)); CHECK(w.angle() == Approx(-107.65_deg));
CHECK(sf::Vector2f::UnitX.angleTo(w) == Approx(-107.65_deg)); CHECK(sf::Vector2f::UnitX.angleTo(w) == Approx(-107.65_deg));
@ -284,18 +287,18 @@ TEST_CASE("[System] sf::Vector2")
CHECK(v.rotatedBy(-158.9902_deg) * ratio == Approx(w)); CHECK(v.rotatedBy(-158.9902_deg) * ratio == Approx(w));
CHECK(w.rotatedBy(158.9902_deg) / ratio == Approx(v)); CHECK(w.rotatedBy(158.9902_deg) / ratio == Approx(v));
CHECK(v.perpendicular() == sf::Vector2f(-3.0f, 2.4f)); STATIC_CHECK(v.perpendicular() == sf::Vector2f(-3.0f, 2.4f));
CHECK(v.perpendicular().perpendicular().perpendicular().perpendicular() == v); STATIC_CHECK(v.perpendicular().perpendicular().perpendicular().perpendicular() == v);
CHECK(v.rotatedBy(90_deg) == Approx(sf::Vector2f(-3.0f, 2.4f))); CHECK(v.rotatedBy(90_deg) == Approx(sf::Vector2f(-3.0f, 2.4f)));
CHECK(v.rotatedBy(27.14_deg) == Approx(sf::Vector2f(0.767248f, 3.76448f))); CHECK(v.rotatedBy(27.14_deg) == Approx(sf::Vector2f(0.767248f, 3.76448f)));
CHECK(v.rotatedBy(-36.11_deg) == Approx(sf::Vector2f(3.70694f, 1.00925f))); CHECK(v.rotatedBy(-36.11_deg) == Approx(sf::Vector2f(3.70694f, 1.00925f)));
} }
SUBCASE("Products and quotients") SECTION("Products and quotients")
{ {
const sf::Vector2f v(2.4f, 3.0f); constexpr sf::Vector2f v(2.4f, 3.0f);
const sf::Vector2f w(-0.7f, -2.2f); constexpr sf::Vector2f w(-0.7f, -2.2f);
CHECK(v.dot(w) == Approx(-8.28f)); CHECK(v.dot(w) == Approx(-8.28f));
CHECK(w.dot(v) == Approx(-8.28f)); CHECK(w.dot(v) == Approx(-8.28f));
@ -309,36 +312,36 @@ TEST_CASE("[System] sf::Vector2")
CHECK(w.cwiseDiv(v) == Approx(sf::Vector2f(-0.291666f, -0.733333f))); CHECK(w.cwiseDiv(v) == Approx(sf::Vector2f(-0.291666f, -0.733333f)));
} }
SUBCASE("Projection") SECTION("Projection")
{ {
const sf::Vector2f v(2.4f, 3.0f); constexpr sf::Vector2f v(2.4f, 3.0f);
const sf::Vector2f w(-0.7f, -2.2f); constexpr sf::Vector2f w(-0.7f, -2.2f);
CHECK(v.projectedOnto(w) == Approx(sf::Vector2f(1.087430f, 3.417636f))); CHECK(v.projectedOnto(w) == Approx(sf::Vector2f(1.087430f, 3.417636f)));
CHECK(v.projectedOnto(w) == Approx(sf::Vector2f(-1.55347f * w))); CHECK(v.projectedOnto(w) == Approx(-1.55347f * w));
CHECK(w.projectedOnto(v) == Approx(sf::Vector2f(-1.346342f, -1.682927f))); CHECK(w.projectedOnto(v) == Approx(sf::Vector2f(-1.346342f, -1.682927f)));
CHECK(w.projectedOnto(v) == Approx(sf::Vector2f(-0.560976f * v))); CHECK(w.projectedOnto(v) == Approx(-0.560976f * v));
CHECK(v.projectedOnto(sf::Vector2f::UnitX) == Approx(sf::Vector2f(2.4f, 0.0f))); CHECK(v.projectedOnto(sf::Vector2f::UnitX) == Approx(sf::Vector2f(2.4f, 0.0f)));
CHECK(v.projectedOnto(sf::Vector2f::UnitY) == Approx(sf::Vector2f(0.0f, 3.0f))); CHECK(v.projectedOnto(sf::Vector2f::UnitY) == Approx(sf::Vector2f(0.0f, 3.0f)));
} }
SUBCASE("Constexpr support") SECTION("Constexpr support")
{ {
constexpr sf::Vector2i v(1, 2); constexpr sf::Vector2i v(1, 2);
constexpr sf::Vector2i w(2, -3); constexpr sf::Vector2i w(2, -3);
static_assert(v.x == 1); STATIC_CHECK(v.x == 1);
static_assert(v.y == 2); STATIC_CHECK(v.y == 2);
static_assert(v + w == sf::Vector2i(3, -1)); STATIC_CHECK(v + w == sf::Vector2i(3, -1));
static_assert(v.lengthSq() == 5); STATIC_CHECK(v.lengthSq() == 5);
static_assert(v.perpendicular() == sf::Vector2i(-2, 1)); STATIC_CHECK(v.perpendicular() == sf::Vector2i(-2, 1));
static_assert(v.dot(w) == -4); STATIC_CHECK(v.dot(w) == -4);
static_assert(v.cross(w) == -7); STATIC_CHECK(v.cross(w) == -7);
static_assert(v.cwiseMul(w) == sf::Vector2i(2, -6)); STATIC_CHECK(v.cwiseMul(w) == sf::Vector2i(2, -6));
static_assert(w.cwiseDiv(v) == sf::Vector2i(2, -1)); STATIC_CHECK(w.cwiseDiv(v) == sf::Vector2i(2, -1));
} }
} }

150
test/System/Vector3.test.cpp
View File

@ -1,6 +1,6 @@
#include <SFML/System/Vector3.hpp> #include <SFML/System/Vector3.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <SystemUtil.hpp> #include <SystemUtil.hpp>
#include <type_traits> #include <type_traits>
@ -8,61 +8,64 @@
// Use sf::Vector3i for tests (except for float vector algebra). // Use sf::Vector3i for tests (except for float vector algebra).
// Test coverage is given, as there are no template specializations. // Test coverage is given, as there are no template specializations.
static_assert(std::is_copy_constructible_v<sf::Vector3i>);
static_assert(std::is_copy_assignable_v<sf::Vector3i>);
static_assert(std::is_nothrow_move_constructible_v<sf::Vector3i>);
static_assert(std::is_nothrow_move_assignable_v<sf::Vector3i>);
TEST_CASE("[System] sf::Vector3") TEST_CASE("[System] sf::Vector3")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::Vector3i>);
STATIC_CHECK(std::is_copy_assignable_v<sf::Vector3i>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Vector3i>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Vector3i>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::Vector3i vector; constexpr sf::Vector3i vector;
CHECK(vector.x == 0); STATIC_CHECK(vector.x == 0);
CHECK(vector.y == 0); STATIC_CHECK(vector.y == 0);
CHECK(vector.z == 0); STATIC_CHECK(vector.z == 0);
} }
SUBCASE("(x, y, z) coordinate constructor") SECTION("(x, y, z) coordinate constructor")
{ {
const sf::Vector3i vector(1, 2, 3); constexpr sf::Vector3i vector(1, 2, 3);
CHECK(vector.x == 1); STATIC_CHECK(vector.x == 1);
CHECK(vector.y == 2); STATIC_CHECK(vector.y == 2);
CHECK(vector.z == 3); STATIC_CHECK(vector.z == 3);
} }
SUBCASE("Conversion constructor") SECTION("Conversion constructor")
{ {
const sf::Vector3f sourceVector(1.0f, 2.0f, 3.0f); constexpr sf::Vector3f sourceVector(1.0f, 2.0f, 3.0f);
const sf::Vector3i vector(sourceVector); constexpr sf::Vector3i vector(sourceVector);
CHECK(vector.x == static_cast<int>(sourceVector.x)); STATIC_CHECK(vector.x == static_cast<int>(sourceVector.x));
CHECK(vector.y == static_cast<int>(sourceVector.y)); STATIC_CHECK(vector.y == static_cast<int>(sourceVector.y));
CHECK(vector.z == static_cast<int>(sourceVector.z)); STATIC_CHECK(vector.z == static_cast<int>(sourceVector.z));
} }
} }
SUBCASE("Unary operations") SECTION("Unary operations")
{ {
SUBCASE("-vector") SECTION("-vector")
{ {
const sf::Vector3i vector(1, 2, 3); constexpr sf::Vector3i vector(1, 2, 3);
const sf::Vector3i negatedVector = -vector; constexpr sf::Vector3i negatedVector = -vector;
CHECK(negatedVector.x == -1); STATIC_CHECK(negatedVector.x == -1);
CHECK(negatedVector.y == -2); STATIC_CHECK(negatedVector.y == -2);
CHECK(negatedVector.z == -3); STATIC_CHECK(negatedVector.z == -3);
} }
} }
SUBCASE("Arithmetic operations between two vectors") SECTION("Arithmetic operations between two vectors")
{ {
sf::Vector3i firstVector(2, 5, 6); sf::Vector3i firstVector(2, 5, 6);
const sf::Vector3i secondVector(8, 3, 7); constexpr sf::Vector3i secondVector(8, 3, 7);
SUBCASE("vector += vector") SECTION("vector += vector")
{ {
firstVector += secondVector; firstVector += secondVector;
@ -71,7 +74,7 @@ TEST_CASE("[System] sf::Vector3")
CHECK(firstVector.z == 13); CHECK(firstVector.z == 13);
} }
SUBCASE("vector -= vector") SECTION("vector -= vector")
{ {
firstVector -= secondVector; firstVector -= secondVector;
@ -80,7 +83,7 @@ TEST_CASE("[System] sf::Vector3")
CHECK(firstVector.z == -1); CHECK(firstVector.z == -1);
} }
SUBCASE("vector + vector") SECTION("vector + vector")
{ {
const sf::Vector3i result = firstVector + secondVector; const sf::Vector3i result = firstVector + secondVector;
@ -89,7 +92,7 @@ TEST_CASE("[System] sf::Vector3")
CHECK(result.z == 13); CHECK(result.z == 13);
} }
SUBCASE("vector - vector") SECTION("vector - vector")
{ {
const sf::Vector3i result = firstVector - secondVector; const sf::Vector3i result = firstVector - secondVector;
@ -99,30 +102,30 @@ TEST_CASE("[System] sf::Vector3")
} }
} }
SUBCASE("Arithmetic operations between vector and scalar value") SECTION("Arithmetic operations between vector and scalar value")
{ {
sf::Vector3i vector(26, 12, 6); sf::Vector3i vector(26, 12, 6);
const int scalar = 2; constexpr int scalar = 2;
SUBCASE("vector * scalar") SECTION("vector * scalar")
{ {
sf::Vector3i result = vector * scalar; const sf::Vector3i result = vector * scalar;
CHECK(result.x == 52); CHECK(result.x == 52);
CHECK(result.y == 24); CHECK(result.y == 24);
CHECK(result.z == 12); CHECK(result.z == 12);
} }
SUBCASE("scalar * vector") SECTION("scalar * vector")
{ {
sf::Vector3i result = scalar * vector; const sf::Vector3i result = scalar * vector;
CHECK(result.x == 52); CHECK(result.x == 52);
CHECK(result.y == 24); CHECK(result.y == 24);
CHECK(result.z == 12); CHECK(result.z == 12);
} }
SUBCASE("vector *= scalar") SECTION("vector *= scalar")
{ {
vector *= scalar; vector *= scalar;
@ -131,16 +134,16 @@ TEST_CASE("[System] sf::Vector3")
CHECK(vector.z == 12); CHECK(vector.z == 12);
} }
SUBCASE("vector / scalar") SECTION("vector / scalar")
{ {
sf::Vector3i result = vector / scalar; const sf::Vector3i result = vector / scalar;
CHECK(result.x == 13); CHECK(result.x == 13);
CHECK(result.y == 6); CHECK(result.y == 6);
CHECK(result.z == 3); CHECK(result.z == 3);
} }
SUBCASE("vector /= scalar") SECTION("vector /= scalar")
{ {
vector /= scalar; vector /= scalar;
@ -150,30 +153,30 @@ TEST_CASE("[System] sf::Vector3")
} }
} }
SUBCASE("Comparison operations (two equal and one different vector)") SECTION("Comparison operations (two equal and one different vector)")
{ {
const sf::Vector3i firstEqualVector(1, 5, 6); constexpr sf::Vector3i firstEqualVector(1, 5, 6);
const sf::Vector3i secondEqualVector(1, 5, 6); constexpr sf::Vector3i secondEqualVector(1, 5, 6);
const sf::Vector3i differentVector(6, 9, 7); constexpr sf::Vector3i differentVector(6, 9, 7);
SUBCASE("vector == vector") SECTION("vector == vector")
{ {
CHECK(firstEqualVector == secondEqualVector); STATIC_CHECK(firstEqualVector == secondEqualVector);
CHECK_FALSE(firstEqualVector == differentVector); STATIC_CHECK_FALSE(firstEqualVector == differentVector);
} }
SUBCASE("vector != vector") SECTION("vector != vector")
{ {
CHECK(firstEqualVector != differentVector); STATIC_CHECK(firstEqualVector != differentVector);
CHECK_FALSE(firstEqualVector != secondEqualVector); STATIC_CHECK_FALSE(firstEqualVector != secondEqualVector);
} }
} }
SUBCASE("Structured bindings") SECTION("Structured bindings")
{ {
sf::Vector3i vector(1, 2, 3); sf::Vector3i vector(1, 2, 3); // NOLINT(misc-const-correctness)
SUBCASE("destructure by value") SECTION("destructure by value")
{ {
auto [x, y, z] = vector; auto [x, y, z] = vector;
@ -181,7 +184,7 @@ TEST_CASE("[System] sf::Vector3")
CHECK(y == 2); CHECK(y == 2);
CHECK(z == 3); CHECK(z == 3);
static_assert(std::is_same_v<decltype(x), decltype(vector.x)>); STATIC_CHECK(std::is_same_v<decltype(x), decltype(vector.x)>);
x = 3; x = 3;
@ -189,7 +192,7 @@ TEST_CASE("[System] sf::Vector3")
CHECK(vector.x == 1); CHECK(vector.x == 1);
} }
SUBCASE("destructure by ref") SECTION("destructure by ref")
{ {
auto& [x, y, z] = vector; auto& [x, y, z] = vector;
@ -197,7 +200,7 @@ TEST_CASE("[System] sf::Vector3")
CHECK(y == 2); CHECK(y == 2);
CHECK(z == 3); CHECK(z == 3);
static_assert(std::is_same_v<decltype(x), decltype(vector.x)>); STATIC_CHECK(std::is_same_v<decltype(x), decltype(vector.x)>);
x = 3; x = 3;
@ -206,19 +209,19 @@ TEST_CASE("[System] sf::Vector3")
} }
} }
SUBCASE("Length and normalization") SECTION("Length and normalization")
{ {
const sf::Vector3f v(2.4f, 3.0f, 5.2f); constexpr sf::Vector3f v(2.4f, 3.0f, 5.2f);
CHECK(v.length() == Approx(6.46529f)); CHECK(v.length() == Approx(6.46529f));
CHECK(v.lengthSq() == Approx(41.79997f)); CHECK(v.lengthSq() == Approx(41.79997f));
CHECK(v.normalized() == Approx(sf::Vector3f(0.37121f, 0.46401f, 0.80429f))); CHECK(v.normalized() == Approx(sf::Vector3f(0.37121f, 0.46401f, 0.80429f)));
} }
SUBCASE("Products and quotients") SECTION("Products and quotients")
{ {
const sf::Vector3f v(2.4f, 3.0f, 5.2f); constexpr sf::Vector3f v(2.4f, 3.0f, 5.2f);
const sf::Vector3f w(-0.7f, -2.2f, -4.8f); constexpr sf::Vector3f w(-0.7f, -2.2f, -4.8f);
CHECK(v.dot(w) == Approx(-33.24f)); CHECK(v.dot(w) == Approx(-33.24f));
CHECK(w.dot(v) == Approx(-33.24f)); CHECK(w.dot(v) == Approx(-33.24f));
@ -231,13 +234,4 @@ TEST_CASE("[System] sf::Vector3")
CHECK(v.cwiseDiv(w) == Approx(sf::Vector3f(-3.428571f, -1.363636f, -1.0833333f))); CHECK(v.cwiseDiv(w) == Approx(sf::Vector3f(-3.428571f, -1.363636f, -1.0833333f)));
CHECK(w.cwiseDiv(v) == Approx(sf::Vector3f(-0.291666f, -0.733333f, -0.9230769f))); CHECK(w.cwiseDiv(v) == Approx(sf::Vector3f(-0.291666f, -0.733333f, -0.9230769f)));
} }
SUBCASE("Constexpr support")
{
constexpr sf::Vector3i vector(1, 2, 3);
static_assert(vector.x == 1);
static_assert(vector.y == 2);
static_assert(vector.z == 3);
static_assert(vector + sf::Vector3i(3, 2, 1) == sf::Vector3i(4, 4, 4));
}
} }

2
test/TestUtilities/GraphicsUtil.hpp
View File

@ -1,7 +1,7 @@
// Header for SFML unit tests. // Header for SFML unit tests.
// //
// For a new graphics module test case, include this header. // For a new graphics module test case, include this header.
// This ensures that string conversions are visible and can be used by doctest for debug output. // This ensures that string conversions are visible and can be used by Catch2 for debug output.
#pragma once #pragma once

5
test/TestUtilities/SystemUtil.cpp
View File

@ -4,7 +4,8 @@
#include <SFML/System/Vector2.hpp> #include <SFML/System/Vector2.hpp>
#include <SFML/System/Vector3.hpp> #include <SFML/System/Vector3.hpp>
#include <doctest/doctest.h> #include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include <SystemUtil.hpp> #include <SystemUtil.hpp>
#include <iomanip> #include <iomanip>
@ -58,7 +59,7 @@ template std::ostream& operator<<(std::ostream&, const Vector3<float>&);
bool operator==(const float& lhs, const Approx<float>& rhs) bool operator==(const float& lhs, const Approx<float>& rhs)
{ {
return static_cast<double>(lhs) == doctest::Approx(static_cast<double>(rhs.value)); return static_cast<double>(lhs) == Catch::Approx(static_cast<double>(rhs.value)).margin(1e-5);
} }
bool operator==(const sf::Vector2f& lhs, const Approx<sf::Vector2f>& rhs) bool operator==(const sf::Vector2f& lhs, const Approx<sf::Vector2f>& rhs)

4
test/TestUtilities/SystemUtil.hpp
View File

@ -1,13 +1,13 @@
// Header for SFML unit tests. // Header for SFML unit tests.
// //
// For a new system module test case, include this header. // For a new system module test case, include this header.
// This ensures that string conversions are visible and can be used by doctest for debug output. // This ensures that string conversions are visible and can be used by Catch2 for debug output.
#pragma once #pragma once
#include <iosfwd> #include <iosfwd>
// String conversions for doctest framework // String conversions for Catch2
namespace sf namespace sf
{ {
class Angle; class Angle;

11
test/TestUtilities/WindowUtil.cpp
View File

@ -3,6 +3,17 @@
#include <ostream> #include <ostream>
std::string runDisplayTests()
{
#ifdef SFML_RUN_DISPLAY_TESTS
return "";
#else
// https://github.com/catchorg/Catch2/blob/devel/docs/test-cases-and-sections.md#special-tags
// This tag tells Catch2 to not run a given TEST_CASE
return "[.display]";
#endif
}
namespace sf namespace sf
{ {
std::ostream& operator<<(std::ostream& os, const VideoMode& videoMode) std::ostream& operator<<(std::ostream& os, const VideoMode& videoMode)

13
test/TestUtilities/WindowUtil.hpp
View File

@ -1,19 +1,18 @@
// Header for SFML unit tests. // Header for SFML unit tests.
// //
// For a new window module test case, include this header. // For a new window module test case, include this header.
// This ensures that string conversions are visible and can be used by doctest for debug output. // This ensures that string conversions are visible and can be used by Catch2 for debug output.
#pragma once #pragma once
#include <SystemUtil.hpp> #include <SystemUtil.hpp>
#include <string>
#ifdef SFML_RUN_DISPLAY_TESTS // Required because WindowUtil.cpp doesn't include WindowUtil.hpp
static constexpr bool skipDisplayTests = false; // NOLINTNEXTLINE(readability-redundant-declaration)
#else std::string runDisplayTests();
static constexpr bool skipDisplayTests = true;
#endif
// String conversions for doctest framework // String conversions for Catch2
namespace sf namespace sf
{ {
class VideoMode; class VideoMode;

32
test/Window/Context.test.cpp
View File

@ -3,7 +3,7 @@
// Other 1st party headers // Other 1st party headers
#include <SFML/Window/ContextSettings.hpp> #include <SFML/Window/ContextSettings.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <WindowUtil.hpp> #include <WindowUtil.hpp>
#include <string> #include <string>
@ -15,21 +15,24 @@
#define GLAPI #define GLAPI
#endif #endif
static_assert(!std::is_copy_constructible_v<sf::Context>); TEST_CASE("[Window] sf::Context", runDisplayTests())
static_assert(!std::is_copy_assignable_v<sf::Context>);
static_assert(!std::is_nothrow_move_constructible_v<sf::Context>);
static_assert(!std::is_nothrow_move_assignable_v<sf::Context>);
TEST_CASE("[Window] sf::Context" * doctest::skip(skipDisplayTests))
{ {
SUBCASE("Construction") SECTION("Type traits")
{
STATIC_CHECK(!std::is_copy_constructible_v<sf::Context>);
STATIC_CHECK(!std::is_copy_assignable_v<sf::Context>);
STATIC_CHECK(!std::is_nothrow_move_constructible_v<sf::Context>);
STATIC_CHECK(!std::is_nothrow_move_assignable_v<sf::Context>);
}
SECTION("Construction")
{ {
const sf::Context context; const sf::Context context;
CHECK(context.getSettings().majorVersion > 0); CHECK(context.getSettings().majorVersion > 0);
} }
SUBCASE("Version String") SECTION("Version String")
{ {
sf::Context context; sf::Context context;
@ -39,7 +42,7 @@ TEST_CASE("[Window] sf::Context" * doctest::skip(skipDisplayTests))
auto glGetStringFunc = reinterpret_cast<glGetStringFuncType>(sf::Context::getFunction("glGetString")); auto glGetStringFunc = reinterpret_cast<glGetStringFuncType>(sf::Context::getFunction("glGetString"));
REQUIRE_UNARY(!!glGetStringFunc); REQUIRE(glGetStringFunc);
constexpr unsigned int glVendor = 0x1F00; constexpr unsigned int glVendor = 0x1F00;
constexpr unsigned int glRenderer = 0x1F01; constexpr unsigned int glRenderer = 0x1F01;
@ -53,11 +56,8 @@ TEST_CASE("[Window] sf::Context" * doctest::skip(skipDisplayTests))
REQUIRE(renderer != nullptr); REQUIRE(renderer != nullptr);
REQUIRE(version != nullptr); REQUIRE(version != nullptr);
MESSAGE("\nOpenGL vendor: ", SUCCEED(std::string("OpenGL vendor: ") + vendor);
std::string(vendor), SUCCEED(std::string("OpenGL renderer: ") + renderer);
"\nOpenGL renderer: ", SUCCEED(std::string("OpenGL version: ") + version);
std::string(renderer),
"\nOpenGL version: ",
std::string(version));
} }
} }

53
test/Window/ContextSettings.test.cpp
View File

@ -1,40 +1,43 @@
#include <SFML/Window/ContextSettings.hpp> #include <SFML/Window/ContextSettings.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::ContextSettings>);
static_assert(std::is_copy_assignable_v<sf::ContextSettings>);
static_assert(std::is_nothrow_move_constructible_v<sf::ContextSettings>);
static_assert(std::is_nothrow_move_assignable_v<sf::ContextSettings>);
TEST_CASE("[Window] sf::ContextSettings") TEST_CASE("[Window] sf::ContextSettings")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::ContextSettings>);
STATIC_CHECK(std::is_copy_assignable_v<sf::ContextSettings>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::ContextSettings>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::ContextSettings>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::ContextSettings contextSettings; constexpr sf::ContextSettings contextSettings;
CHECK(contextSettings.depthBits == 0); STATIC_CHECK(contextSettings.depthBits == 0);
CHECK(contextSettings.stencilBits == 0); STATIC_CHECK(contextSettings.stencilBits == 0);
CHECK(contextSettings.antialiasingLevel == 0); STATIC_CHECK(contextSettings.antialiasingLevel == 0);
CHECK(contextSettings.majorVersion == 1); STATIC_CHECK(contextSettings.majorVersion == 1);
CHECK(contextSettings.minorVersion == 1); STATIC_CHECK(contextSettings.minorVersion == 1);
CHECK(contextSettings.attributeFlags == sf::ContextSettings::Default); STATIC_CHECK(contextSettings.attributeFlags == sf::ContextSettings::Default);
CHECK(contextSettings.sRgbCapable == false); STATIC_CHECK(contextSettings.sRgbCapable == false);
} }
SUBCASE("Verbose constructor") SECTION("Verbose constructor")
{ {
const sf::ContextSettings contextSettings(1, 1, 2, 3, 5, sf::ContextSettings::Core, true); constexpr sf::ContextSettings contextSettings(1, 1, 2, 3, 5, sf::ContextSettings::Core, true);
CHECK(contextSettings.depthBits == 1); STATIC_CHECK(contextSettings.depthBits == 1);
CHECK(contextSettings.stencilBits == 1); STATIC_CHECK(contextSettings.stencilBits == 1);
CHECK(contextSettings.antialiasingLevel == 2); STATIC_CHECK(contextSettings.antialiasingLevel == 2);
CHECK(contextSettings.majorVersion == 3); STATIC_CHECK(contextSettings.majorVersion == 3);
CHECK(contextSettings.minorVersion == 5); STATIC_CHECK(contextSettings.minorVersion == 5);
CHECK(contextSettings.attributeFlags == sf::ContextSettings::Core); STATIC_CHECK(contextSettings.attributeFlags == sf::ContextSettings::Core);
CHECK(contextSettings.sRgbCapable == true); STATIC_CHECK(contextSettings.sRgbCapable == true);
} }
} }
} }

31
test/Window/Cursor.test.cpp
View File

@ -1,33 +1,36 @@
#include <SFML/Window/Cursor.hpp> #include <SFML/Window/Cursor.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <WindowUtil.hpp> #include <WindowUtil.hpp>
#include <array> #include <array>
#include <type_traits> #include <type_traits>
static_assert(!std::is_copy_constructible_v<sf::Cursor>); // Skip these tests with [.display] because they fail when using DRM which hasn't implemented sf::Cursor
static_assert(!std::is_copy_assignable_v<sf::Cursor>); TEST_CASE("[Window] sf::Cursor", "[.display]")
static_assert(std::is_nothrow_move_constructible_v<sf::Cursor>);
static_assert(std::is_nothrow_move_assignable_v<sf::Cursor>);
// Skip these tests because they fail when using DRM which hasn't implemented sf::Cursor
TEST_CASE("[Window] sf::Cursor" * doctest::skip(true))
{ {
SUBCASE("Construction") SECTION("Type traits")
{
STATIC_CHECK(!std::is_copy_constructible_v<sf::Cursor>);
STATIC_CHECK(!std::is_copy_assignable_v<sf::Cursor>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::Cursor>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::Cursor>);
}
SECTION("Construction")
{ {
const sf::Cursor cursor; const sf::Cursor cursor;
} }
SUBCASE("Move semantics") SECTION("Move semantics")
{ {
SUBCASE("Construction") SECTION("Construction")
{ {
sf::Cursor movedCursor; sf::Cursor movedCursor;
const sf::Cursor cursor(std::move(movedCursor)); const sf::Cursor cursor(std::move(movedCursor));
} }
SUBCASE("Assignment") SECTION("Assignment")
{ {
sf::Cursor movedCursor; sf::Cursor movedCursor;
sf::Cursor cursor; sf::Cursor cursor;
@ -35,7 +38,7 @@ TEST_CASE("[Window] sf::Cursor" * doctest::skip(true))
} }
} }
SUBCASE("loadFromPixels()") SECTION("loadFromPixels()")
{ {
sf::Cursor cursor; sf::Cursor cursor;
std::array<std::uint8_t, 4> pixels{}; std::array<std::uint8_t, 4> pixels{};
@ -46,7 +49,7 @@ TEST_CASE("[Window] sf::Cursor" * doctest::skip(true))
CHECK(cursor.loadFromPixels(pixels.data(), {1, 1}, {})); CHECK(cursor.loadFromPixels(pixels.data(), {1, 1}, {}));
} }
SUBCASE("loadFromSystem()") SECTION("loadFromSystem()")
{ {
sf::Cursor cursor; sf::Cursor cursor;
CHECK(cursor.loadFromSystem(sf::Cursor::Hand)); CHECK(cursor.loadFromSystem(sf::Cursor::Hand));

37
test/Window/VideoMode.test.cpp
View File

@ -1,34 +1,37 @@
#include <SFML/Window/VideoMode.hpp> #include <SFML/Window/VideoMode.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <WindowUtil.hpp> #include <WindowUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(std::is_copy_constructible_v<sf::VideoMode>);
static_assert(std::is_copy_assignable_v<sf::VideoMode>);
static_assert(std::is_nothrow_move_constructible_v<sf::VideoMode>);
static_assert(std::is_nothrow_move_assignable_v<sf::VideoMode>);
TEST_CASE("[Window] sf::VideoMode") TEST_CASE("[Window] sf::VideoMode")
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(std::is_copy_constructible_v<sf::VideoMode>);
STATIC_CHECK(std::is_copy_assignable_v<sf::VideoMode>);
STATIC_CHECK(std::is_nothrow_move_constructible_v<sf::VideoMode>);
STATIC_CHECK(std::is_nothrow_move_assignable_v<sf::VideoMode>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
sf::VideoMode videoMode; sf::VideoMode videoMode;
CHECK(videoMode.size == sf::Vector2u(0, 0)); CHECK(videoMode.size == sf::Vector2u(0, 0));
CHECK(videoMode.bitsPerPixel == 0); CHECK(videoMode.bitsPerPixel == 0);
} }
SUBCASE("Width, height constructor") SECTION("Width, height constructor")
{ {
sf::VideoMode videoMode({800, 600}); sf::VideoMode videoMode({800, 600});
CHECK(videoMode.size == sf::Vector2u(800, 600)); CHECK(videoMode.size == sf::Vector2u(800, 600));
CHECK(videoMode.bitsPerPixel == 32); CHECK(videoMode.bitsPerPixel == 32);
} }
SUBCASE("Width, height, bit depth constructor") SECTION("Width, height, bit depth constructor")
{ {
sf::VideoMode videoMode({800, 600}, 24); sf::VideoMode videoMode({800, 600}, 24);
CHECK(videoMode.size == sf::Vector2u(800, 600)); CHECK(videoMode.size == sf::Vector2u(800, 600));
@ -36,16 +39,16 @@ TEST_CASE("[Window] sf::VideoMode")
} }
} }
SUBCASE("Operators") SECTION("Operators")
{ {
SUBCASE("operator==") SECTION("operator==")
{ {
CHECK(sf::VideoMode() == sf::VideoMode()); CHECK(sf::VideoMode() == sf::VideoMode());
CHECK(sf::VideoMode({0, 0}, 0) == sf::VideoMode({0, 0}, 0)); CHECK(sf::VideoMode({0, 0}, 0) == sf::VideoMode({0, 0}, 0));
CHECK(sf::VideoMode({1080, 1920}, 64) == sf::VideoMode({1080, 1920}, 64)); CHECK(sf::VideoMode({1080, 1920}, 64) == sf::VideoMode({1080, 1920}, 64));
} }
SUBCASE("operator!=") SECTION("operator!=")
{ {
CHECK(sf::VideoMode() != sf::VideoMode({1, 0})); CHECK(sf::VideoMode() != sf::VideoMode({1, 0}));
CHECK(sf::VideoMode() != sf::VideoMode({0, 1})); CHECK(sf::VideoMode() != sf::VideoMode({0, 1}));
@ -54,7 +57,7 @@ TEST_CASE("[Window] sf::VideoMode")
CHECK(sf::VideoMode({1080, 1920}, 16) != sf::VideoMode({400, 600})); CHECK(sf::VideoMode({1080, 1920}, 16) != sf::VideoMode({400, 600}));
} }
SUBCASE("operator<") SECTION("operator<")
{ {
CHECK(sf::VideoMode() < sf::VideoMode({0, 0}, 1)); CHECK(sf::VideoMode() < sf::VideoMode({0, 0}, 1));
CHECK(sf::VideoMode({800, 800}, 24) < sf::VideoMode({1080, 1920}, 48)); CHECK(sf::VideoMode({800, 800}, 24) < sf::VideoMode({1080, 1920}, 48));
@ -62,7 +65,7 @@ TEST_CASE("[Window] sf::VideoMode")
CHECK(sf::VideoMode({400, 400}, 48) < sf::VideoMode({400, 600}, 48)); CHECK(sf::VideoMode({400, 400}, 48) < sf::VideoMode({400, 600}, 48));
} }
SUBCASE("operator>") SECTION("operator>")
{ {
CHECK(sf::VideoMode({1, 0}) > sf::VideoMode({0, 0}, 1)); CHECK(sf::VideoMode({1, 0}) > sf::VideoMode({0, 0}, 1));
CHECK(sf::VideoMode({800, 800}, 48) > sf::VideoMode({1080, 1920}, 24)); CHECK(sf::VideoMode({800, 800}, 48) > sf::VideoMode({1080, 1920}, 24));
@ -70,7 +73,7 @@ TEST_CASE("[Window] sf::VideoMode")
CHECK(sf::VideoMode({400, 600}, 48) > sf::VideoMode({400, 400}, 48)); CHECK(sf::VideoMode({400, 600}, 48) > sf::VideoMode({400, 400}, 48));
} }
SUBCASE("operator<=") SECTION("operator<=")
{ {
CHECK(sf::VideoMode() <= sf::VideoMode({0, 0}, 1)); CHECK(sf::VideoMode() <= sf::VideoMode({0, 0}, 1));
CHECK(sf::VideoMode({800, 800}, 24) <= sf::VideoMode({1080, 1920}, 48)); CHECK(sf::VideoMode({800, 800}, 24) <= sf::VideoMode({1080, 1920}, 48));
@ -81,7 +84,7 @@ TEST_CASE("[Window] sf::VideoMode")
CHECK(sf::VideoMode({1080, 1920}, 64) <= sf::VideoMode({1080, 1920}, 64)); CHECK(sf::VideoMode({1080, 1920}, 64) <= sf::VideoMode({1080, 1920}, 64));
} }
SUBCASE("operator>=") SECTION("operator>=")
{ {
CHECK(sf::VideoMode({1, 0}) >= sf::VideoMode({0, 0}, 1)); CHECK(sf::VideoMode({1, 0}) >= sf::VideoMode({0, 0}, 1));
CHECK(sf::VideoMode({800, 800}, 48) >= sf::VideoMode({1080, 1920}, 24)); CHECK(sf::VideoMode({800, 800}, 48) >= sf::VideoMode({1080, 1920}, 24));

19
test/Window/Window.test.cpp
View File

@ -5,19 +5,22 @@
#include <SFML/System/String.hpp> #include <SFML/System/String.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <WindowUtil.hpp> #include <WindowUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(!std::is_copy_constructible_v<sf::Window>); TEST_CASE("[Window] sf::Window", runDisplayTests())
static_assert(!std::is_copy_assignable_v<sf::Window>);
static_assert(!std::is_nothrow_move_constructible_v<sf::Window>);
static_assert(!std::is_nothrow_move_assignable_v<sf::Window>);
TEST_CASE("[Window] sf::Window" * doctest::skip(skipDisplayTests))
{ {
SUBCASE("Construction") SECTION("Type traits")
{
STATIC_CHECK(!std::is_copy_constructible_v<sf::Window>);
STATIC_CHECK(!std::is_copy_assignable_v<sf::Window>);
STATIC_CHECK(!std::is_nothrow_move_constructible_v<sf::Window>);
STATIC_CHECK(!std::is_nothrow_move_assignable_v<sf::Window>);
}
SECTION("Construction")
{ {
const sf::Window window(sf::VideoMode(sf::Vector2u(256, 256), 32), const sf::Window window(sf::VideoMode(sf::Vector2u(256, 256), 32),
"Window Title", "Window Title",

53
test/Window/WindowBase.test.cpp
View File

@ -6,21 +6,24 @@
#include <SFML/System/String.hpp> #include <SFML/System/String.hpp>
#include <doctest/doctest.h> #include <catch2/catch_test_macros.hpp>
#include <WindowUtil.hpp> #include <WindowUtil.hpp>
#include <type_traits> #include <type_traits>
static_assert(!std::is_copy_constructible_v<sf::WindowBase>); TEST_CASE("[Window] sf::WindowBase", runDisplayTests())
static_assert(!std::is_copy_assignable_v<sf::WindowBase>);
static_assert(!std::is_nothrow_move_constructible_v<sf::WindowBase>);
static_assert(!std::is_nothrow_move_assignable_v<sf::WindowBase>);
TEST_CASE("[Window] sf::WindowBase" * doctest::skip(skipDisplayTests))
{ {
SUBCASE("Construction") SECTION("Type traits")
{ {
SUBCASE("Default constructor") STATIC_CHECK(!std::is_copy_constructible_v<sf::WindowBase>);
STATIC_CHECK(!std::is_copy_assignable_v<sf::WindowBase>);
STATIC_CHECK(!std::is_nothrow_move_constructible_v<sf::WindowBase>);
STATIC_CHECK(!std::is_nothrow_move_assignable_v<sf::WindowBase>);
}
SECTION("Construction")
{
SECTION("Default constructor")
{ {
const sf::WindowBase windowBase; const sf::WindowBase windowBase;
CHECK(!windowBase.isOpen()); CHECK(!windowBase.isOpen());
@ -30,7 +33,7 @@ TEST_CASE("[Window] sf::WindowBase" * doctest::skip(skipDisplayTests))
CHECK(windowBase.getSystemHandle() == sf::WindowHandle()); CHECK(windowBase.getSystemHandle() == sf::WindowHandle());
} }
SUBCASE("Mode and title constructor") SECTION("Mode and title constructor")
{ {
const sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests"); const sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests");
CHECK(windowBase.isOpen()); CHECK(windowBase.isOpen());
@ -38,7 +41,7 @@ TEST_CASE("[Window] sf::WindowBase" * doctest::skip(skipDisplayTests))
CHECK(windowBase.getSystemHandle() != sf::WindowHandle()); CHECK(windowBase.getSystemHandle() != sf::WindowHandle());
} }
SUBCASE("Mode, title, and style constructor") SECTION("Mode, title, and style constructor")
{ {
const sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests", sf::Style::Resize); const sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests", sf::Style::Resize);
CHECK(windowBase.isOpen()); CHECK(windowBase.isOpen());
@ -47,11 +50,11 @@ TEST_CASE("[Window] sf::WindowBase" * doctest::skip(skipDisplayTests))
} }
} }
SUBCASE("create()") SECTION("create()")
{ {
sf::WindowBase windowBase; sf::WindowBase windowBase;
SUBCASE("Mode and title") SECTION("Mode and title")
{ {
windowBase.create(sf::VideoMode({240, 360}), "WindowBase Tests"); windowBase.create(sf::VideoMode({240, 360}), "WindowBase Tests");
CHECK(windowBase.isOpen()); CHECK(windowBase.isOpen());
@ -59,7 +62,7 @@ TEST_CASE("[Window] sf::WindowBase" * doctest::skip(skipDisplayTests))
CHECK(windowBase.getSystemHandle() != sf::WindowHandle()); CHECK(windowBase.getSystemHandle() != sf::WindowHandle());
} }
SUBCASE("Mode, title, and style") SECTION("Mode, title, and style")
{ {
windowBase.create(sf::VideoMode({240, 360}), "WindowBase Tests", sf::Style::Resize); windowBase.create(sf::VideoMode({240, 360}), "WindowBase Tests", sf::Style::Resize);
CHECK(windowBase.isOpen()); CHECK(windowBase.isOpen());
@ -68,51 +71,51 @@ TEST_CASE("[Window] sf::WindowBase" * doctest::skip(skipDisplayTests))
} }
} }
SUBCASE("close()") SECTION("close()")
{ {
sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests"); sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests");
windowBase.close(); windowBase.close();
CHECK(!windowBase.isOpen()); CHECK(!windowBase.isOpen());
} }
SUBCASE("pollEvent()") SECTION("pollEvent()")
{ {
sf::WindowBase windowBase; sf::WindowBase windowBase;
sf::Event event; sf::Event event;
CHECK(!windowBase.pollEvent(event)); CHECK(!windowBase.pollEvent(event));
} }
SUBCASE("waitEvent()") SECTION("waitEvent()")
{ {
sf::WindowBase windowBase; sf::WindowBase windowBase;
sf::Event event; sf::Event event;
CHECK(!windowBase.waitEvent(event)); CHECK(!windowBase.waitEvent(event));
} }
SUBCASE("Set/get position") SECTION("Set/get position")
{ {
sf::WindowBase windowBase; sf::WindowBase windowBase;
windowBase.setPosition({12, 34}); windowBase.setPosition({12, 34});
CHECK(windowBase.getPosition() == sf::Vector2i()); CHECK(windowBase.getPosition() == sf::Vector2i());
} }
SUBCASE("Set/get size") SECTION("Set/get size")
{ {
SUBCASE("Uninitialized window") SECTION("Uninitialized window")
{ {
sf::WindowBase windowBase; sf::WindowBase windowBase;
windowBase.setSize({128, 256}); windowBase.setSize({128, 256});
CHECK(windowBase.getSize() == sf::Vector2u()); CHECK(windowBase.getSize() == sf::Vector2u());
} }
SUBCASE("Initialized window") SECTION("Initialized window")
{ {
sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests"); sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests");
windowBase.setSize({128, 256}); windowBase.setSize({128, 256});
CHECK(windowBase.getSize() == sf::Vector2u(128, 256)); CHECK(windowBase.getSize() == sf::Vector2u(128, 256));
} }
SUBCASE("Minimum size") SECTION("Minimum size")
{ {
sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests"); sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests");
windowBase.setMinimumSize(sf::Vector2u(128, 256)); windowBase.setMinimumSize(sf::Vector2u(128, 256));
@ -120,7 +123,7 @@ TEST_CASE("[Window] sf::WindowBase" * doctest::skip(skipDisplayTests))
CHECK(windowBase.getSize() == sf::Vector2u(128, 256)); CHECK(windowBase.getSize() == sf::Vector2u(128, 256));
} }
SUBCASE("Maximum size") SECTION("Maximum size")
{ {
sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests"); sf::WindowBase windowBase(sf::VideoMode({360, 240}), "WindowBase Tests");
windowBase.setMaximumSize(sf::Vector2u(128, 256)); windowBase.setMaximumSize(sf::Vector2u(128, 256));
@ -129,7 +132,7 @@ TEST_CASE("[Window] sf::WindowBase" * doctest::skip(skipDisplayTests))
} }
} }
SUBCASE("setMinimumSize()") SECTION("setMinimumSize()")
{ {
sf::WindowBase windowBase(sf::VideoMode({100, 100}), "WindowBase Tests", sf::Style::Default ^ sf::Style::Resize); sf::WindowBase windowBase(sf::VideoMode({100, 100}), "WindowBase Tests", sf::Style::Default ^ sf::Style::Resize);
windowBase.setMinimumSize(sf::Vector2u(200, 300)); windowBase.setMinimumSize(sf::Vector2u(200, 300));
@ -137,7 +140,7 @@ TEST_CASE("[Window] sf::WindowBase" * doctest::skip(skipDisplayTests))
windowBase.setMaximumSize(sf::Vector2u(200, 300)); windowBase.setMaximumSize(sf::Vector2u(200, 300));
} }
SUBCASE("setMinimumSize()") SECTION("setMinimumSize()")
{ {
sf::WindowBase windowBase(sf::VideoMode({400, 400}), "WindowBase Tests", sf::Style::Default ^ sf::Style::Resize); sf::WindowBase windowBase(sf::VideoMode({400, 400}), "WindowBase Tests", sf::Style::Default ^ sf::Style::Resize);
windowBase.setMaximumSize(sf::Vector2u(200, 300)); windowBase.setMaximumSize(sf::Vector2u(200, 300));