Fix clang-tidy-19 errors

.clang-tidy

@@ -19,6 +19,7 @@ Checks: >
   -bugprone-narrowing-conversions,
   -bugprone-signed-char-misuse,
   -bugprone-string-integer-assignment,
+  -bugprone-suspicious-stringview-data-usage,
   -bugprone-switch-missing-default-case,
   -bugprone-unchecked-optional-access,
   -clang-analyzer-nullability.NullablePassedToNonnull,
@@ -27,6 +28,7 @@ Checks: >
   -clang-analyzer-optin.osx.*,
   -clang-analyzer-osx.*,
   -clang-analyzer-unix.Malloc,
+  -clang-analyzer-unix.StdCLibraryFunctions,
   -cppcoreguidelines-avoid-c-arrays,
   -cppcoreguidelines-avoid-const-or-ref-data-members,
   -cppcoreguidelines-avoid-do-while,
@@ -62,11 +64,13 @@ Checks: >
   -readability-avoid-nested-conditional-operator,
   -readability-braces-around-statements,
   -readability-convert-member-functions-to-static,
+  -readability-enum-initial-value,
   -readability-function-cognitive-complexity,
   -readability-function-size,
   -readability-identifier-length,
   -readability-implicit-bool-conversion,
   -readability-magic-numbers,
+  -readability-math-missing-parentheses,
   -readability-named-parameter,
   -readability-redundant-casting,
   -readability-uppercase-literal-suffix,

examples/ftp/Ftp.cpp

@@ -7,6 +7,8 @@
 #include <optional>
 
 
+namespace
+{
 ////////////////////////////////////////////////////////////
 /// Print a FTP response into a standard output stream
 ///
@@ -15,6 +17,7 @@ std::ostream& operator<<(std::ostream& stream, const sf::Ftp::Response& response
 {
     return stream << static_cast<int>(response.getStatus()) << response.getMessage();
 }
+} // namespace
 
 
 ////////////////////////////////////////////////////////////

examples/island/Island.cpp

@@ -69,208 +69,6 @@ float snowcapHeight = 0.6f;
 float heightFactor  = static_cast<float>(windowSize.y) / 2.0f;
 float heightFlatten = 3.0f;
 float lightFactor   = 0.7f;
-} // namespace
-
-
-// Forward declarations of the functions we define further down
-void threadFunction();
-void generateTerrain(sf::Vertex* vertexBuffer);
-
-
-////////////////////////////////////////////////////////////
-/// Entry point of application
-///
-/// \return Application exit code
-///
-////////////////////////////////////////////////////////////
-int main()
-{
-    // Create the window of the application
-    sf::RenderWindow window(sf::VideoMode(windowSize), "SFML Island", sf::Style::Titlebar | sf::Style::Close);
-    window.setVerticalSyncEnabled(true);
-
-    const sf::Font font("resources/tuffy.ttf");
-
-    // Create all of our graphics resources
-    sf::Text         hudText(font);
-    sf::Text         statusText(font);
-    sf::Shader       terrainShader;
-    sf::RenderStates terrainStates;
-    sf::VertexBuffer terrain(sf::PrimitiveType::Triangles, sf::VertexBuffer::Usage::Static);
-
-    // Set up our text drawables
-    statusText.setCharacterSize(28);
-    statusText.setFillColor(sf::Color::White);
-    statusText.setOutlineColor(sf::Color::Black);
-    statusText.setOutlineThickness(2.0f);
-
-    hudText.setCharacterSize(14);
-    hudText.setFillColor(sf::Color::White);
-    hudText.setOutlineColor(sf::Color::Black);
-    hudText.setOutlineThickness(2.0f);
-    hudText.setPosition({5.0f, 5.0f});
-
-    // Staging buffer for our terrain data that we will upload to our VertexBuffer
-    std::vector<sf::Vertex> terrainStagingBuffer;
-
-    // Set up our graphics resources and set the status text accordingly
-    if (!sf::VertexBuffer::isAvailable() || !sf::Shader::isAvailable())
-    {
-        statusText.setString("Shaders and/or Vertex Buffers Unsupported");
-    }
-    else if (!terrainShader.loadFromFile("resources/terrain.vert", "resources/terrain.frag"))
-    {
-        statusText.setString("Failed to load shader program");
-    }
-    else
-    {
-        // Start up our thread pool
-        for (unsigned int i = 0; i < threadCount; ++i)
-        {
-            threads.emplace_back(threadFunction);
-        }
-
-        // Create our VertexBuffer with enough space to hold all the terrain geometry
-        if (!terrain.create(resolution.x * resolution.y * 6))
-        {
-            std::cerr << "Failed to create vertex buffer" << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        // Resize the staging buffer to be able to hold all the terrain geometry
-        terrainStagingBuffer.resize(resolution.x * resolution.y * 6);
-
-        // Generate the initial terrain
-        generateTerrain(terrainStagingBuffer.data());
-
-        statusText.setString("Generating Terrain...");
-
-        // Set up the render states
-        terrainStates = sf::RenderStates(&terrainShader);
-    }
-
-    // Center the status text
-    statusText.setPosition((sf::Vector2f(windowSize) - statusText.getLocalBounds().size) / 2.f);
-
-    // Set up an array of pointers to our settings for arrow navigation
-    constexpr std::array<Setting, 9> settings = {
-        {{"perlinFrequency", &perlinFrequency},
-         {"perlinFrequencyBase", &perlinFrequencyBase},
-         {"heightBase", &heightBase},
-         {"edgeFactor", &edgeFactor},
-         {"edgeDropoffExponent", &edgeDropoffExponent},
-         {"snowcapHeight", &snowcapHeight},
-         {"heightFactor", &heightFactor},
-         {"heightFlatten", &heightFlatten},
-         {"lightFactor", &lightFactor}}};
-
-    std::size_t currentSetting = 0;
-
-    std::ostringstream osstr;
-    sf::Clock          clock;
-
-    while (window.isOpen())
-    {
-        // Handle events
-        while (const std::optional event = window.pollEvent())
-        {
-            // Window closed or escape key pressed: exit
-            if (event->is<sf::Event::Closed>() ||
-                (event->is<sf::Event::KeyPressed>() &&
-                 event->getIf<sf::Event::KeyPressed>()->code == sf::Keyboard::Key::Escape))
-            {
-                window.close();
-                break;
-            }
-
-            // Arrow key pressed:
-            // TODO Replace use of getNativeHandle() when validity function is added
-            if (terrainShader.getNativeHandle() != 0 && event->is<sf::Event::KeyPressed>())
-            {
-                switch (event->getIf<sf::Event::KeyPressed>()->code)
-                {
-                    case sf::Keyboard::Key::Enter:
-                        generateTerrain(terrainStagingBuffer.data());
-                        break;
-                    case sf::Keyboard::Key::Down:
-                        currentSetting = (currentSetting + 1) % settings.size();
-                        break;
-                    case sf::Keyboard::Key::Up:
-                        currentSetting = (currentSetting + settings.size() - 1) % settings.size();
-                        break;
-                    case sf::Keyboard::Key::Left:
-                        *(settings[currentSetting].value) -= 0.1f;
-                        break;
-                    case sf::Keyboard::Key::Right:
-                        *(settings[currentSetting].value) += 0.1f;
-                        break;
-                    default:
-                        break;
-                }
-            }
-        }
-
-        // Clear, draw graphics objects and display
-        window.clear();
-
-        window.draw(statusText);
-
-        if (terrainShader.getNativeHandle() != 0)
-        {
-            {
-                const std::lock_guard lock(workQueueMutex);
-
-                // Don't bother updating/drawing the VertexBuffer while terrain is being regenerated
-                if (!pendingWorkCount)
-                {
-                    // If there is new data pending to be uploaded to the VertexBuffer, do it now
-                    if (bufferUploadPending)
-                    {
-                        if (!terrain.update(terrainStagingBuffer.data()))
-                        {
-                            std::cerr << "Failed to update vertex buffer" << std::endl;
-                            return EXIT_FAILURE;
-                        }
-
-                        bufferUploadPending = false;
-                    }
-
-                    terrainShader.setUniform("lightFactor", lightFactor);
-                    window.draw(terrain, terrainStates);
-                }
-            }
-
-            // Update and draw the HUD text
-            osstr.str("");
-            osstr << "Frame:  " << clock.restart().asMilliseconds() << "ms\n"
-                  << "perlinOctaves:  " << perlinOctaves << "\n\n"
-                  << "Use the arrow keys to change the values.\nUse the return key to regenerate the terrain.\n\n";
-
-            for (std::size_t i = 0; i < settings.size(); ++i)
-                osstr << ((i == currentSetting) ? ">>  " : "       ") << settings[i].name << ":  "
-                      << *(settings[i].value) << '\n';
-
-            hudText.setString(osstr.str());
-
-            window.draw(hudText);
-        }
-
-        // Display things on screen
-        window.display();
-    }
-
-    // Shut down our thread pool
-    {
-        const std::lock_guard lock(workQueueMutex);
-        workPending = false;
-    }
-
-    while (!threads.empty())
-    {
-        threads.back().join();
-        threads.pop_back();
-    }
-}
 
 
 ////////////////////////////////////////////////////////////
@@ -620,3 +418,200 @@ void generateTerrain(sf::Vertex* buffer)
         pendingWorkCount = blockCount;
     }
 }
+} // namespace
+
+
+////////////////////////////////////////////////////////////
+/// Entry point of application
+///
+/// \return Application exit code
+///
+////////////////////////////////////////////////////////////
+int main()
+{
+    // Create the window of the application
+    sf::RenderWindow window(sf::VideoMode(windowSize), "SFML Island", sf::Style::Titlebar | sf::Style::Close);
+    window.setVerticalSyncEnabled(true);
+
+    const sf::Font font("resources/tuffy.ttf");
+
+    // Create all of our graphics resources
+    sf::Text         hudText(font);
+    sf::Text         statusText(font);
+    sf::Shader       terrainShader;
+    sf::RenderStates terrainStates;
+    sf::VertexBuffer terrain(sf::PrimitiveType::Triangles, sf::VertexBuffer::Usage::Static);
+
+    // Set up our text drawables
+    statusText.setCharacterSize(28);
+    statusText.setFillColor(sf::Color::White);
+    statusText.setOutlineColor(sf::Color::Black);
+    statusText.setOutlineThickness(2.0f);
+
+    hudText.setCharacterSize(14);
+    hudText.setFillColor(sf::Color::White);
+    hudText.setOutlineColor(sf::Color::Black);
+    hudText.setOutlineThickness(2.0f);
+    hudText.setPosition({5.0f, 5.0f});
+
+    // Staging buffer for our terrain data that we will upload to our VertexBuffer
+    std::vector<sf::Vertex> terrainStagingBuffer;
+
+    // Set up our graphics resources and set the status text accordingly
+    if (!sf::VertexBuffer::isAvailable() || !sf::Shader::isAvailable())
+    {
+        statusText.setString("Shaders and/or Vertex Buffers Unsupported");
+    }
+    else if (!terrainShader.loadFromFile("resources/terrain.vert", "resources/terrain.frag"))
+    {
+        statusText.setString("Failed to load shader program");
+    }
+    else
+    {
+        // Start up our thread pool
+        for (unsigned int i = 0; i < threadCount; ++i)
+        {
+            threads.emplace_back(threadFunction);
+        }
+
+        // Create our VertexBuffer with enough space to hold all the terrain geometry
+        if (!terrain.create(resolution.x * resolution.y * 6))
+        {
+            std::cerr << "Failed to create vertex buffer" << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        // Resize the staging buffer to be able to hold all the terrain geometry
+        terrainStagingBuffer.resize(resolution.x * resolution.y * 6);
+
+        // Generate the initial terrain
+        generateTerrain(terrainStagingBuffer.data());
+
+        statusText.setString("Generating Terrain...");
+
+        // Set up the render states
+        terrainStates = sf::RenderStates(&terrainShader);
+    }
+
+    // Center the status text
+    statusText.setPosition((sf::Vector2f(windowSize) - statusText.getLocalBounds().size) / 2.f);
+
+    // Set up an array of pointers to our settings for arrow navigation
+    constexpr std::array<Setting, 9> settings = {
+        {{"perlinFrequency", &perlinFrequency},
+         {"perlinFrequencyBase", &perlinFrequencyBase},
+         {"heightBase", &heightBase},
+         {"edgeFactor", &edgeFactor},
+         {"edgeDropoffExponent", &edgeDropoffExponent},
+         {"snowcapHeight", &snowcapHeight},
+         {"heightFactor", &heightFactor},
+         {"heightFlatten", &heightFlatten},
+         {"lightFactor", &lightFactor}}};
+
+    std::size_t currentSetting = 0;
+
+    std::ostringstream osstr;
+    sf::Clock          clock;
+
+    while (window.isOpen())
+    {
+        // Handle events
+        while (const std::optional event = window.pollEvent())
+        {
+            // Window closed or escape key pressed: exit
+            if (event->is<sf::Event::Closed>() ||
+                (event->is<sf::Event::KeyPressed>() &&
+                 event->getIf<sf::Event::KeyPressed>()->code == sf::Keyboard::Key::Escape))
+            {
+                window.close();
+                break;
+            }
+
+            // Arrow key pressed:
+            // TODO Replace use of getNativeHandle() when validity function is added
+            if (terrainShader.getNativeHandle() != 0 && event->is<sf::Event::KeyPressed>())
+            {
+                switch (event->getIf<sf::Event::KeyPressed>()->code)
+                {
+                    case sf::Keyboard::Key::Enter:
+                        generateTerrain(terrainStagingBuffer.data());
+                        break;
+                    case sf::Keyboard::Key::Down:
+                        currentSetting = (currentSetting + 1) % settings.size();
+                        break;
+                    case sf::Keyboard::Key::Up:
+                        currentSetting = (currentSetting + settings.size() - 1) % settings.size();
+                        break;
+                    case sf::Keyboard::Key::Left:
+                        *(settings[currentSetting].value) -= 0.1f;
+                        break;
+                    case sf::Keyboard::Key::Right:
+                        *(settings[currentSetting].value) += 0.1f;
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+
+        // Clear, draw graphics objects and display
+        window.clear();
+
+        window.draw(statusText);
+
+        if (terrainShader.getNativeHandle() != 0)
+        {
+            {
+                const std::lock_guard lock(workQueueMutex);
+
+                // Don't bother updating/drawing the VertexBuffer while terrain is being regenerated
+                if (!pendingWorkCount)
+                {
+                    // If there is new data pending to be uploaded to the VertexBuffer, do it now
+                    if (bufferUploadPending)
+                    {
+                        if (!terrain.update(terrainStagingBuffer.data()))
+                        {
+                            std::cerr << "Failed to update vertex buffer" << std::endl;
+                            return EXIT_FAILURE;
+                        }
+
+                        bufferUploadPending = false;
+                    }
+
+                    terrainShader.setUniform("lightFactor", lightFactor);
+                    window.draw(terrain, terrainStates);
+                }
+            }
+
+            // Update and draw the HUD text
+            osstr.str("");
+            osstr << "Frame:  " << clock.restart().asMilliseconds() << "ms\n"
+                  << "perlinOctaves:  " << perlinOctaves << "\n\n"
+                  << "Use the arrow keys to change the values.\nUse the return key to regenerate the terrain.\n\n";
+
+            for (std::size_t i = 0; i < settings.size(); ++i)
+                osstr << ((i == currentSetting) ? ">>  " : "       ") << settings[i].name << ":  "
+                      << *(settings[i].value) << '\n';
+
+            hudText.setString(osstr.str());
+
+            window.draw(hudText);
+        }
+
+        // Display things on screen
+        window.display();
+    }
+
+    // Shut down our thread pool
+    {
+        const std::lock_guard lock(workQueueMutex);
+        workPending = false;
+    }
+
+    while (!threads.empty())
+    {
+        threads.back().join();
+        threads.pop_back();
+    }
+}

examples/opengl/OpenGL.cpp

@@ -20,6 +20,8 @@
 #define GL_SRGB8_ALPHA8 0x8C43
 #endif
 
+namespace
+{
 std::filesystem::path resourcesDir()
 {
 #ifdef SFML_SYSTEM_IOS
@@ -28,6 +30,7 @@ std::filesystem::path resourcesDir()
     return "resources";
 #endif
 }
+} // namespace
 
 ////////////////////////////////////////////////////////////
 /// Entry point of application

examples/sockets/Sockets.cpp

@@ -1,15 +1,12 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
+#include "TCP.hpp"
+#include "UDP.hpp"
+
 #include <iostream>
 
 
-void runTcpServer(unsigned short port);
-void runTcpClient(unsigned short port);
-void runUdpServer(unsigned short port);
-void runUdpClient(unsigned short port);
-
-
 ////////////////////////////////////////////////////////////
 /// Entry point of application
 ///

examples/sockets/TCP.cpp

@@ -1,6 +1,8 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
+#include "TCP.hpp"
+
 #include <SFML/Network.hpp>
 
 #include <iomanip>

examples/sockets/TCP.hpp

@@ -0,0 +1,4 @@
+#pragma once
+
+void runTcpServer(unsigned short port);
+void runTcpClient(unsigned short port);

examples/sockets/UDP.cpp

@@ -1,6 +1,8 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
+#include "UDP.hpp"
+
 #include <SFML/Network.hpp>
 
 #include <iomanip>

examples/sockets/UDP.hpp

@@ -0,0 +1,4 @@
+#pragma once
+
+void runUdpServer(unsigned short port);
+void runUdpClient(unsigned short port);

examples/sound/Sound.cpp

@@ -6,6 +6,8 @@
 #include <iostream>
 
 
+namespace
+{
 ////////////////////////////////////////////////////////////
 /// Play a sound
 ///
@@ -69,6 +71,7 @@ void playMusic(const std::filesystem::path& filename)
 
     std::cout << '\n' << std::endl;
 }
+} // namespace
 
 
 ////////////////////////////////////////////////////////////

examples/tennis/Tennis.cpp

@@ -16,6 +16,8 @@
 #include <SFML/Main.hpp>
 #endif
 
+namespace
+{
 std::filesystem::path resourcesDir()
 {
 #ifdef SFML_SYSTEM_IOS
@@ -24,6 +26,7 @@ std::filesystem::path resourcesDir()
     return "resources";
 #endif
 }
+} // namespace
 
 ////////////////////////////////////////////////////////////
 /// Entry point of application

examples/voip/Client.cpp

@@ -1,6 +1,8 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
+#include "Client.hpp"
+
 #include <SFML/Audio.hpp>
 
 #include <SFML/Network.hpp>

examples/voip/Client.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+void doClient(unsigned short port);

examples/voip/Server.cpp

@@ -1,6 +1,8 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
+#include "Server.hpp"
+
 #include <SFML/Audio.hpp>
 
 #include <SFML/Network.hpp>

examples/voip/Server.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+void doServer(unsigned short port);

examples/voip/VoIP.cpp

@@ -1,17 +1,12 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
+#include "Client.hpp"
+#include "Server.hpp"
+
 #include <iostream>
 
 
-////////////////////////////////////////////////////////////
-// Function prototypes
-// (I'm too lazy to put them into separate headers...)
-////////////////////////////////////////////////////////////
-void doClient(unsigned short port);
-void doServer(unsigned short port);
-
-
 ////////////////////////////////////////////////////////////
 /// Entry point of application
 ///

src/SFML/Graphics/GLExtensions.cpp

@@ -50,7 +50,7 @@
 #endif
 
 
-namespace sf::priv
+namespace
 {
 ////////////////////////////////////////////////////////////
 void extensionSanityCheck()
@@ -82,8 +82,10 @@ void extensionSanityCheck()
     check(GLEXT_copy_buffer_dependencies);
 #endif
 }
+} // namespace
 
-
+namespace sf::priv
+{
 ////////////////////////////////////////////////////////////
 void ensureExtensionsInit()
 {

src/SFML/Network/SocketSelector.cpp

@@ -31,6 +31,7 @@
 
 #include <SFML/System/Err.hpp>
 
+#include <algorithm>
 #include <memory>
 #include <ostream>
 #include <utility>
@@ -119,8 +120,7 @@ void SocketSelector::add(Socket& socket)
         }
 
         // SocketHandle is an int in POSIX
-        if (m_impl->maxSocket < handle)
+        m_impl->maxSocket = std::max(m_impl->maxSocket, handle);
-            m_impl->maxSocket = handle;
 
 #endif
 

src/SFML/Window/GlContext.cpp

@@ -388,7 +388,7 @@ struct GlContext::TransientContext
     ////////////////////////////////////////////////////////////
     static std::optional<TransientContext>& get()
     {
-        thread_local std::optional<TransientContext> transientContext;
+        static thread_local std::optional<TransientContext> transientContext;
         return transientContext;
     }
 

src/SFML/Window/macOS/SFKeyboardModifiersHelper.mm

@@ -75,33 +75,40 @@ namespace
 /// Share 'modifiers' state with all windows to correctly fire pressed/released events
 ModifiersState state;
 BOOL           isStateInitialized = NO;
+
+////////////////////////////////////////////////////////
+BOOL isKeyMaskActive(NSUInteger modifiers, NSUInteger mask)
+{
+    // Here we need to make sure it's exactly the mask since some masks
+    // share some bits such that the & operation would result in a non zero
+    // value without corresponding to the processed key.
+    return (modifiers & mask) == mask;
 }
 
-
+////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////
-// Local & Private Functions
-////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////
-/// \brief Carefully observe if the key mask is on in the modifiers
-///
-////////////////////////////////////////////////////////////
-BOOL isKeyMaskActive(NSUInteger modifiers, NSUInteger mask);
-
-
-////////////////////////////////////////////////////////////
-/// \brief Handle one modifier key mask
-///
-/// Update the key state and send events to the requester
-///
-////////////////////////////////////////////////////////////
 void processOneModifier(NSUInteger                 modifiers,
                         NSUInteger                 mask,
                         BOOL&                      wasDown,
                         sf::Keyboard::Key          key,
                         sf::Keyboard::Scancode     code,
-                        sf::priv::WindowImplCocoa& requester);
+                        sf::priv::WindowImplCocoa& requester)
+{
+    // State
+    const BOOL isDown = isKeyMaskActive(modifiers, mask);
 
+    // Check for key pressed event
+    if (isDown && !wasDown)
+        requester.keyDown(keyPressedEventWithModifiers(modifiers, key, code));
+
+    // And check for key released event
+    else if (!isDown && wasDown)
+        requester.keyUp(keyReleasedEventWithModifiers(modifiers, key, code));
+
+    // else isDown == wasDown, so no change
+
+    // Update state
+    wasDown = isDown;
+}
 
 ////////////////////////////////////////////////////////////
 /// \brief Handle left & right modifier keys
@@ -119,12 +126,12 @@ void processLeftRightModifiers(
     sf::Keyboard::Key          rightKey,
     sf::Keyboard::Scancode     leftCode,
     sf::Keyboard::Scancode     rightCode,
-    sf::priv::WindowImplCocoa& requester);
+    sf::priv::WindowImplCocoa& requester)
-
+{
-
+    processOneModifier(modifiers, leftMask, leftWasDown, leftKey, leftCode, requester);
-////////////////////////////////////////////////////////////
+    processOneModifier(modifiers, rightMask, rightWasDown, rightKey, rightCode, requester);
-// Implementations
+}
-////////////////////////////////////////////////////////////
+}
 
 
 ////////////////////////////////////////////////////////
@@ -237,57 +244,3 @@ void handleModifiersChanged(NSUInteger modifiers, sf::priv::WindowImplCocoa& req
                        sf::Keyboard::Scan::CapsLock,
                        requester);
 }
-
-
-////////////////////////////////////////////////////////
-BOOL isKeyMaskActive(NSUInteger modifiers, NSUInteger mask)
-{
-    // Here we need to make sure it's exactly the mask since some masks
-    // share some bits such that the & operation would result in a non zero
-    // value without corresponding to the processed key.
-    return (modifiers & mask) == mask;
-}
-
-
-////////////////////////////////////////////////////////
-void processOneModifier(NSUInteger                 modifiers,
-                        NSUInteger                 mask,
-                        BOOL&                      wasDown,
-                        sf::Keyboard::Key          key,
-                        sf::Keyboard::Scancode     code,
-                        sf::priv::WindowImplCocoa& requester)
-{
-    // State
-    const BOOL isDown = isKeyMaskActive(modifiers, mask);
-
-    // Check for key pressed event
-    if (isDown && !wasDown)
-        requester.keyDown(keyPressedEventWithModifiers(modifiers, key, code));
-
-    // And check for key released event
-    else if (!isDown && wasDown)
-        requester.keyUp(keyReleasedEventWithModifiers(modifiers, key, code));
-
-    // else isDown == wasDown, so no change
-
-    // Update state
-    wasDown = isDown;
-}
-
-
-////////////////////////////////////////////////////////
-void processLeftRightModifiers(
-    NSUInteger                 modifiers,
-    NSUInteger                 leftMask,
-    NSUInteger                 rightMask,
-    BOOL&                      leftWasDown,
-    BOOL&                      rightWasDown,
-    sf::Keyboard::Key          leftKey,
-    sf::Keyboard::Key          rightKey,
-    sf::Keyboard::Scancode     leftCode,
-    sf::Keyboard::Scancode     rightCode,
-    sf::priv::WindowImplCocoa& requester)
-{
-    processOneModifier(modifiers, leftMask, leftWasDown, leftKey, leftCode, requester);
-    processOneModifier(modifiers, rightMask, rightWasDown, rightKey, rightCode, requester);
-}

src/SFML/Window/macOS/WindowImplCocoa.mm

@@ -69,7 +69,6 @@ NSString* sfStringToNSString(const sf::String& string)
     NSString* const str = [[NSString alloc] initWithBytes:data length:length encoding:encoding];
     return [str autorelease];
 }
-}
 
 
 ////////////////////////////////////////////////////////
@@ -94,6 +93,7 @@ void showMouseCursor()
         isCursorHidden = false;
     }
 }
+}
 
 #pragma mark
 #pragma mark WindowImplCocoa's ctor/dtor

test/TestUtilities/GraphicsUtil.hpp

@@ -11,6 +11,8 @@
 namespace sf
 {
 struct BlendMode;
+enum class StencilComparison;
+enum class StencilUpdateOperation;
 struct StencilMode;
 class Color;
 class Transform;
@@ -19,6 +21,8 @@ template <typename>
 class Rect;
 
 std::ostream& operator<<(std::ostream& os, const BlendMode& blendMode);
+std::ostream& operator<<(std::ostream& os, const StencilComparison& comparison);
+std::ostream& operator<<(std::ostream& os, const StencilUpdateOperation& updateOperation);
 std::ostream& operator<<(std::ostream& os, const StencilMode& stencilMode);
 std::ostream& operator<<(std::ostream& os, Color color);
 std::ostream& operator<<(std::ostream& os, const Transform& transform);

test/TestUtilities/WindowUtil.cpp

@@ -1,4 +1,5 @@
-// Note: No need to increase compile time by including TestUtilities/Window.hpp
+#include "WindowUtil.hpp"
+
 #include <SFML/Window/VideoMode.hpp>
 
 #include <ostream>

test/TestUtilities/WindowUtil.hpp

@@ -8,8 +8,6 @@
 #include <SystemUtil.hpp>
 #include <string>
 
-// Required because WindowUtil.cpp doesn't include WindowUtil.hpp
-// NOLINTNEXTLINE(readability-redundant-declaration)
 std::string runDisplayTests();
 
 // String conversions for Catch2
@@ -17,7 +15,5 @@ namespace sf
 {
 class VideoMode;
 
-// Required because WindowUtil.cpp doesn't include WindowUtil.hpp
-// NOLINTNEXTLINE(readability-redundant-declaration)
 std::ostream& operator<<(std::ostream& os, const VideoMode& videoMode);
 } // namespace sf