refactor: leaner mouse drag test implementation

developer239 · developer239 · commit 5871fa1cf474 · 2025-03-11T10:48:47.000+01:00
diff --git a/tests/sdl/MouseTests.cpp b/tests/sdl/MouseTests.cpp
@@ -21,6 +21,9 @@ TEST_F(MouseDragTest, CanDragElementToNewPosition) {
         "Drag Test Element"
     );
 
+    // Process events for a short while to ensure window is fully rendered
+    processEventsFor(std::chrono::milliseconds(1000));
+
     // Initial position of the element
     const SDL_Rect initialRect = dragElement->getRect();
 
@@ -67,9 +70,16 @@ TEST_F(MouseDragTest, CanDragElementToNewPosition) {
     std::cout << "  Drag end point: ("
               << endPoint.x << ", " << endPoint.y << ")" << std::endl;
 
+    // Add extra render cycle before starting the operation
+    processEventsFor(std::chrono::milliseconds(1000));
+
     // Perform the drag operation
     performMouseDrag(startPoint, endPoint);
 
+    // Add additional delay after drag to ensure events are processed
+    std::cout << "Waiting for drag operation to complete..." << std::endl;
+    processEventsFor(std::chrono::milliseconds(2000));
+
     // Get the element's position after the drag
     const SDL_Rect finalRect = dragElement->getRect();
     std::cout << "  Final element position: ("
diff --git a/tests/sdl/RobotSDLTestFixture.h b/tests/sdl/RobotSDLTestFixture.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <gtest/gtest.h>
-#include <memory>
 #include <functional>
 #include <chrono>
 #include <thread>
@@ -11,153 +10,140 @@
 #include "TestConfig.h"
 #include "TestElements.h"
 #include "../../src/Mouse.h"
-#include "../../src/Utils.h"
 
 namespace RobotTest {
-
-/**
- * @brief Test fixture for SDL-based Robot tests
- *
- * This fixture handles SDL initialization, window creation, and
- * cleanup for all Robot CPP SDL-based tests.
- */
-class RobotSDLTest : public ::testing::Test {
-protected:
-    void SetUp() override {
-        // Initialize test config with reasonable defaults
-        config_ = std::make_unique<TestConfig>();
-
-        // Initialize SDL, window, and renderer
-        context_ = std::make_unique<TestContext>(*config_);
-
-        // Wait for window to be ready
-        context_->prepareForTests();
-        SDL_Delay(static_cast<Uint32>(config_->setupDelay.count()));
-    }
-
-    void TearDown() override {
-        // Clear all test elements
-        testElements_.clear();
-
-        // TestContext destructor will handle SDL cleanup
-        context_.reset();
-    }
-
     /**
-     * @brief Creates a drag element and adds it to the test elements collection
-     * @return Pointer to the created drag element (owned by the fixture)
+     * @brief Test fixture for SDL-based Robot tests
+     *
+     * This fixture handles SDL initialization, window creation, and
+     * cleanup for all Robot CPP SDL-based tests.
      */
-    DragElement* createDragElement(int x, int y, int width, int height,
-                                  Color color, const std::string& name) {
-        auto element = std::make_unique<DragElement>(
-            SDL_Rect{x, y, width, height}, color, name);
-
-        auto* rawPtr = element.get();
-        testElements_.push_back(std::move(element));
-        return rawPtr;
-    }
-
-    /**
-     * @brief Runs the event loop for a specified duration
-     * @param duration How long to process events
-     */
-    void processEventsFor(std::chrono::milliseconds duration) {
-        auto startTime = std::chrono::steady_clock::now();
-        bool running = true;
-
-        while (running &&
-              (std::chrono::steady_clock::now() - startTime < duration)) {
-
-            // Process pending SDL events
-            context_->handleEvents(running);
+    class RobotSDLTest : public ::testing::Test {
+    protected:
+        void SetUp() override {
+            // Initialize test config with reasonable defaults
+            config_ = std::make_unique<TestConfig>();
+
+            // Initialize SDL, window, and renderer
+            context_ = std::make_unique<TestContext>(*config_);
+
+            // Wait for window to be ready
+            context_->prepareForTests();
+            SDL_Delay(static_cast<Uint32>(config_->setupDelay.count()));
+        }
 
-            // Render current state
-            context_->renderFrame([this](SDL_Renderer* renderer) {
-                renderTestElements(renderer);
-            });
+        void TearDown() override {
+            // Clear all test elements
+            testElements_.clear();
 
-            // Limit frame rate
-            SDL_Delay(static_cast<Uint32>(config_->frameDelay.count()));
+            // TestContext destructor will handle SDL cleanup
+            context_.reset();
         }
-    }
-
-    /**
-     * @brief Converts window coordinates to screen coordinates
-     */
-    Robot::Point windowToScreen(int x, int y) const {
-        int windowX, windowY;
-        SDL_GetWindowPosition(context_->getWindow(), &windowX, &windowY);
-        return {x + windowX, y + windowY};
-    }
 
-    /**
-     * @brief Performs a mouse drag operation
-     * @param startPoint Starting point in window coordinates
-     * @param endPoint Ending point in window coordinates
-     */
-    void performMouseDrag(const SDL_Point& startPoint, const SDL_Point& endPoint) {
-        // Convert to screen coordinates
-        Robot::Point startPos = windowToScreen(startPoint.x, startPoint.y);
-        Robot::Point endPos = windowToScreen(endPoint.x, endPoint.y);
+        /**
+         * @brief Creates a drag element and adds it to the test elements collection
+         * @return Pointer to the created drag element (owned by the fixture)
+         */
+        DragElement *createDragElement(int x, int y, int width, int height,
+                                       Color color, const std::string &name) {
+            auto element = std::make_unique<DragElement>(
+                SDL_Rect{x, y, width, height}, color, name);
+
+            auto *rawPtr = element.get();
+            testElements_.push_back(std::move(element));
+            return rawPtr;
+        }
 
-        std::cout << "Moving to start position: " << startPos.x << ", " << startPos.y << std::endl;
+        /**
+         * @brief Runs the event loop for a specified duration
+         * @param duration How long to process events
+         */
+        void processEventsFor(std::chrono::milliseconds duration) {
+            auto startTime = std::chrono::steady_clock::now();
+            bool running = true;
+
+            while (running &&
+                   (std::chrono::steady_clock::now() - startTime < duration)) {
+                // Process pending SDL events
+                context_->handleEvents(running);
+
+                // Render current state
+                context_->renderFrame([this](SDL_Renderer *renderer) {
+                    renderTestElements(renderer);
+                });
+
+                // Limit frame rate
+                SDL_Delay(static_cast<Uint32>(config_->frameDelay.count()));
+            }
+        }
 
-        // Move to start position
-        Robot::Mouse::Move(startPos);
-        Robot::delay(static_cast<unsigned int>(config_->actionDelay.count()));
+        /**
+         * @brief Converts window coordinates to screen coordinates
+         */
+        Robot::Point windowToScreen(int x, int y) const {
+            int windowX, windowY;
+            SDL_GetWindowPosition(context_->getWindow(), &windowX, &windowY);
+            return {x + windowX, y + windowY};
+        }
 
-        // Press mouse button
-        Robot::Mouse::ToggleButton(true, Robot::MouseButton::LEFT_BUTTON);
-        Robot::delay(static_cast<unsigned int>(config_->actionDelay.count()));
+        /**
+             * @brief Performs a mouse drag operation
+             * @param startPoint Starting point in window coordinates
+             * @param endPoint Ending point in window coordinates
+             */
+        void performMouseDrag(const SDL_Point &startPoint, const SDL_Point &endPoint) {
+            // Convert to screen coordinates
+            Robot::Point startPos = windowToScreen(startPoint.x, startPoint.y);
+            Robot::Point endPos = windowToScreen(endPoint.x, endPoint.y);
 
-        // Move to end position
-        std::cout << "Moving to end position: " << endPos.x << ", " << endPos.y << std::endl;
-        Robot::Mouse::Move(endPos);
-        Robot::delay(static_cast<unsigned int>(config_->actionDelay.count()));
+            std::cout << "Moving to start position: " << startPos.x << ", " << startPos.y << std::endl;
 
-        // Release mouse button
-        Robot::Mouse::ToggleButton(false, Robot::MouseButton::LEFT_BUTTON);
+            // Move to start position
+            Robot::Mouse::MoveSmooth(startPos);
 
-        // Process events to ensure drag is applied
-        processEventsFor(std::chrono::milliseconds(500));
-    }
+            // Perform the drag operation using the library's DragSmooth method
+            std::cout << "Performing smooth drag to end position: " << endPos.x << ", " << endPos.y << std::endl;
+            Robot::Mouse::DragSmooth(endPos);
 
-    /**
-     * @brief Renders all test elements
-     */
-    void renderTestElements(SDL_Renderer* renderer) {
-        for (const auto& element : testElements_) {
-            element->draw(renderer);
+            // Process events to ensure drag is applied
+            processEventsFor(std::chrono::milliseconds(1500));
         }
 
-        // Draw mouse cursor position
-        drawMousePosition(renderer);
-    }
+        /**
+         * @brief Renders all test elements
+         */
+        void renderTestElements(SDL_Renderer *renderer) {
+            for (const auto &element: testElements_) {
+                element->draw(renderer);
+            }
 
-    /**
-     * @brief Draws the current mouse position on screen
-     */
-    void drawMousePosition(SDL_Renderer* renderer) {
-        // Get window position
-        int windowX, windowY;
-        SDL_GetWindowPosition(context_->getWindow(), &windowX, &windowY);
-
-        // Get global mouse position
-        Robot::Point globalMousePos = Robot::Mouse::GetPosition();
-
-        // Calculate local mouse position (relative to window)
-        int localMouseX = globalMousePos.x - windowX;
-        int localMouseY = globalMousePos.y - windowY;
-
-        // Draw mouse position indicator - a red crosshair
-        SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
-        SDL_RenderDrawLine(renderer, localMouseX - 10, localMouseY, localMouseX + 10, localMouseY);
-        SDL_RenderDrawLine(renderer, localMouseX, localMouseY - 10, localMouseX, localMouseY + 10);
-    }
+            // Draw mouse cursor position
+            drawMousePosition(renderer);
+        }
 
-    std::unique_ptr<TestConfig> config_;
-    std::unique_ptr<TestContext> context_;
-    std::vector<std::unique_ptr<TestElement>> testElements_;
-};
+        /**
+         * @brief Draws the current mouse position on screen
+         */
+        void drawMousePosition(SDL_Renderer *renderer) {
+            // Get window position
+            int windowX, windowY;
+            SDL_GetWindowPosition(context_->getWindow(), &windowX, &windowY);
+
+            // Get global mouse position
+            Robot::Point globalMousePos = Robot::Mouse::GetPosition();
+
+            // Calculate local mouse position (relative to window)
+            int localMouseX = globalMousePos.x - windowX;
+            int localMouseY = globalMousePos.y - windowY;
+
+            // Draw mouse position indicator - a red crosshair
+            SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
+            SDL_RenderDrawLine(renderer, localMouseX - 10, localMouseY, localMouseX + 10, localMouseY);
+            SDL_RenderDrawLine(renderer, localMouseX, localMouseY - 10, localMouseX, localMouseY + 10);
+        }
 
+        std::unique_ptr<TestConfig> config_;
+        std::unique_ptr<TestContext> context_;
+        std::vector<std::unique_ptr<TestElement> > testElements_;
+    };
 } // namespace RobotTest
diff --git a/tests/sdl/SDLTestMain.cpp b/tests/sdl/SDLTestMain.cpp
@@ -30,7 +30,7 @@ int main(int argc, char** argv) {
     }
 
     // Parse wait time
-    int waitTime = 2000; // Default 2 seconds
+    int waitTime = 2000;
     for (int i = 1; i < argc; ++i) {
         if (std::string(argv[i]) == "--wait-time" && i + 1 < argc) {
             waitTime = std::stoi(argv[i + 1]);
diff --git a/tests/sdl/TestConfig.h b/tests/sdl/TestConfig.h
@@ -2,11 +2,8 @@
 
 #include <chrono>
 #include <string>
-#include <vector>
-#include <optional>
 
 namespace RobotTest {
-
     /**
      * @brief Configuration for tests with default values
      */
@@ -18,13 +15,13 @@ namespace RobotTest {
 
         // Test execution settings
         bool runTests = false;
-        std::chrono::milliseconds initialWaitTime{2000};
-        std::chrono::seconds testTimeout{30};
+        std::chrono::milliseconds initialWaitTime{6000}; // Increased to 6 seconds
+        std::chrono::seconds testTimeout{60}; // Increased to 60 seconds
 
         // Delay settings for animation and visualization
-        std::chrono::milliseconds frameDelay{16};  // ~60 FPS
-        std::chrono::milliseconds setupDelay{500};
-        std::chrono::milliseconds actionDelay{300};
+        std::chrono::milliseconds frameDelay{16}; // ~60 FPS
+        std::chrono::milliseconds setupDelay{1500}; // Increased to 1.5 seconds
+        std::chrono::milliseconds actionDelay{900}; // Increased to 900ms (3x original)
 
         // Window positioning
         int windowX = 50;
@@ -33,26 +30,27 @@ namespace RobotTest {
         // Mouse test settings
         int dragOffsetX = 100;
         int dragOffsetY = 50;
-        int positionTolerance = 20;  // Pixels
+        int positionTolerance = 20; // Pixels
 
         // Parse command line arguments
-        static TestConfig fromCommandLine(int argc, char** argv) {
+        static TestConfig fromCommandLine(int argc, char **argv) {
             TestConfig config;
 
             for (int i = 1; i < argc; i++) {
                 std::string arg = argv[i];
 
                 if (arg == "--run-tests") {
                     config.runTests = true;
-                }
-                else if (arg == "--wait-time" && i + 1 < argc) {
+                } else if (arg == "--wait-time" && i + 1 < argc) {
                     config.initialWaitTime = std::chrono::milliseconds(std::stoi(argv[i + 1]));
                     i++;
+                } else if (arg == "--action-delay" && i + 1 < argc) {
+                    config.actionDelay = std::chrono::milliseconds(std::stoi(argv[i + 1]));
+                    i++;
                 }
             }
 
             return config;
         }
     };
-
 } // namespace RobotTest

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ int main(int argc, char** argv) {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`// Parse wait time`
`33`		`- int waitTime = 2000; // Default 2 seconds`
	`33`	`+ int waitTime = 2000;`
`34`	`34`	`for (int i = 1; i < argc; ++i) {`
`35`	`35`	`if (std::string(argv[i]) == "--wait-time" && i + 1 < argc) {`
`36`	`36`	`waitTime = std::stoi(argv[i + 1]);`