removed clustering

1 files changed, 243 insertions, 0 deletions

diff --git a/tests/unit/test_glamac_view.c b/tests/unit/test_glamac_view.c
new file mode 100644
index 0000000..2decc3f
--- /dev/null
+++ b/tests/unit/test_glamac_view.c
@@ -0,0 +1,243 @@
+/**

+ * test_glamac_view.c - Unit tests for view management

+ *

+ * Copyright (C) 2025 https://optics-design.com

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU Affero General Public License as

+ * published by the Free Software Foundation, either version 3 of the

+ * License, or (at your option) any later version.

+ */

+

+#include "../test_framework.h"

+#include "../../include/glamac_view.h"

+#include "../../include/glass_data.h"

+

+// Test view initialization

+int test_view_initialization() {

+    TEST_START("View Initialization");

+    

+    ViewState view;

+    init_view_state(&view, 800, 600);

+    

+    // Check initial values

+    TEST_ASSERT_FLOAT_EQ(0.0f, view.offsetX, 0.001f, "Initial X offset should be 0");

+    TEST_ASSERT_FLOAT_EQ(0.0f, view.offsetY, 0.001f, "Initial Y offset should be 0");

+    TEST_ASSERT_FLOAT_EQ(1.0f, view.zoomLevel, 0.001f, "Initial zoom should be 1.0");

+    TEST_ASSERT_EQ(800, view.windowWidth, "Window width should be set correctly");

+    TEST_ASSERT_EQ(600, view.windowHeight, "Window height should be set correctly");

+    

+    TEST_END();

+}

+

+// Test coordinate transformations

+int test_coordinate_transformations() {

+    TEST_START("Coordinate Transformations");

+    

+    ViewState view;

+    init_view_state(&view, 800, 600);

+    

+    // Initialize glass data for proper coordinate system

+    initialize_glass_data();

+    

+    // Test glass to screen coordinate conversion

+    i32 screenX, screenY;

+    data_to_screen_coords(60.0f, 1.5f, &view, &screenX, &screenY);

+    

+    // Screen coordinates should be within window bounds for typical glass values

+    TEST_ASSERT(screenX >= 0 && screenX <= view.windowWidth, 

+               "Screen X coordinate should be within window bounds");

+    TEST_ASSERT(screenY >= 0 && screenY <= view.windowHeight, 

+               "Screen Y coordinate should be within window bounds");

+    

+    // Test screen to glass coordinate conversion (inverse operation)

+    f32 abbeNumber, refractiveIndex;

+    screen_to_data_coords(screenX, screenY, &view, &abbeNumber, &refractiveIndex);

+    

+    // The inverse transformation should approximately recover original values

+    TEST_ASSERT_FLOAT_EQ(60.0f, abbeNumber, 1.0f, 

+                        "Inverse transformation should recover Abbe number");

+    TEST_ASSERT_FLOAT_EQ(1.5f, refractiveIndex, 0.01f, 

+                        "Inverse transformation should recover refractive index");

+    

+    cleanup_glass_data();

+    TEST_END();

+}

+

+// Test zoom functionality

+int test_zoom_functionality() {

+    TEST_START("Zoom Functionality");

+    

+    ViewState view;

+    init_view_state(&view, 800, 600);

+    

+    // Test zoom in

+    f32 initial_zoom = view.zoomLevel;

+    handle_mouse_wheel_zoom(1, 400, 300, &view);  // Zoom in at center

+    TEST_ASSERT(view.zoomLevel > initial_zoom, "Zoom should increase");

+    TEST_ASSERT(view.zoomLevel <= MAX_ZOOM, "Zoom should not exceed maximum");

+    

+    // Test zoom out

+    f32 zoomed_in = view.zoomLevel;

+    handle_mouse_wheel_zoom(-1, 400, 300, &view);  // Zoom out at center

+    TEST_ASSERT(view.zoomLevel < zoomed_in, "Zoom should decrease");

+    TEST_ASSERT(view.zoomLevel >= MIN_ZOOM, "Zoom should not go below minimum");

+    

+    // Test zoom limits

+    for (int i = 0; i < 20; i++) {

+        handle_mouse_wheel_zoom(1, 400, 300, &view);  // Zoom in a lot

+    }

+    TEST_ASSERT_FLOAT_EQ(MAX_ZOOM, view.zoomLevel, 0.001f, "Should be clamped to max zoom");

+    

+    for (int i = 0; i < 20; i++) {

+        handle_mouse_wheel_zoom(-1, 400, 300, &view);  // Zoom out a lot

+    }

+    TEST_ASSERT_FLOAT_EQ(MIN_ZOOM, view.zoomLevel, 0.001f, "Should be clamped to min zoom");

+    

+    TEST_END();

+}

+

+// Test panning functionality

+int test_panning_functionality() {

+    TEST_START("Panning Functionality");

+    

+    ViewState view;

+    init_view_state(&view, 800, 600);

+    

+    // Test panning

+    f32 initial_x = view.offsetX;

+    f32 initial_y = view.offsetY;

+    

+    pan_view(&view, 100, 50);  // Pan right and up

+    TEST_ASSERT(view.offsetX != initial_x, "X offset should change with panning");

+    TEST_ASSERT(view.offsetY != initial_y, "Y offset should change with panning");

+    

+    // Test panning in opposite direction

+    pan_view(&view, -100, -50);  // Pan left and down

+    TEST_ASSERT_FLOAT_EQ(initial_x, view.offsetX, 0.1f, 

+                        "Should return to approximately initial X after opposite panning");

+    TEST_ASSERT_FLOAT_EQ(initial_y, view.offsetY, 0.1f, 

+                        "Should return to approximately initial Y after opposite panning");

+    

+    TEST_END();

+}

+

+// Test view fitting

+int test_view_fitting() {

+    TEST_START("View Fitting");

+    

+    ViewState view;

+    init_view_state(&view, 800, 600);

+    

+    // Initialize glass data for fitting

+    initialize_glass_data();

+    

+    // Test fit to data

+    fit_view_to_data(&view);

+    

+    // After fitting, the view should be adjusted to show all data

+    // The exact values depend on the glass data, but zoom and offsets should be reasonable

+    TEST_ASSERT(view.zoomLevel > 0.0f, "Zoom should be positive after fitting");

+    TEST_ASSERT(view.zoomLevel <= MAX_ZOOM, "Zoom should not exceed maximum after fitting");

+    

+    // Offsets should be set to center the data

+    TEST_ASSERT(view.offsetX != 0.0f || view.offsetY != 0.0f, 

+               "At least one offset should be non-zero after fitting (unless data is perfectly centered)");

+    

+    cleanup_glass_data();

+    TEST_END();

+}

+

+// Test clustering functionality

+int test_clustering() {

+    TEST_START("Clustering");

+    

+    ViewState view;

+    init_view_state(&view, 800, 600);

+    

+    // Initialize glass data for clustering

+    initialize_glass_data();

+    

+    // Update clustering

+    update_clustering(&view);

+    

+    // Check that clustering was performed

+    TEST_ASSERT(view.clusterCount >= 0, "Cluster count should be non-negative");

+    TEST_ASSERT(view.clusterCount <= MAX_CLUSTERS, "Cluster count should not exceed maximum");

+    

+    // If we have clusters, test their properties

+    for (u32 i = 0; i < view.clusterCount; i++) {

+        const GlassCluster* cluster = &view.clusters[i];

+        TEST_ASSERT(cluster->count > 0, "Each cluster should have at least one glass");

+        TEST_ASSERT(cluster->count <= MAX_CLUSTER_SIZE, "Cluster size should not exceed maximum");

+        

+        // Center coordinates should be reasonable

+        TEST_ASSERT(cluster->centerX >= 0 && cluster->centerX < view.windowWidth,

+                   "Cluster center X should be within window bounds");

+        TEST_ASSERT(cluster->centerY >= 0 && cluster->centerY < view.windowHeight,

+                   "Cluster center Y should be within window bounds");

+    }

+    

+    cleanup_glass_data();

+    TEST_END();

+}

+

+// Test view reset

+int test_view_reset() {

+    TEST_START("View Reset");

+    

+    ViewState view;

+    init_view_state(&view, 800, 600);

+    

+    // Modify the view

+    view.offsetX = 100.0f;

+    view.offsetY = 50.0f;

+    view.zoomLevel = 2.0f;

+    

+    // Reset view

+    reset_view(&view);

+    

+    // Check that view is back to initial state

+    TEST_ASSERT_FLOAT_EQ(0.0f, view.offsetX, 0.001f, "X offset should be reset to 0");

+    TEST_ASSERT_FLOAT_EQ(0.0f, view.offsetY, 0.001f, "Y offset should be reset to 0");

+    TEST_ASSERT_FLOAT_EQ(1.0f, view.zoomLevel, 0.001f, "Zoom should be reset to 1.0");

+    

+    TEST_END();

+}

+

+// Test window resize handling

+int test_window_resize() {

+    TEST_START("Window Resize");

+    

+    ViewState view;

+    init_view_state(&view, 800, 600);

+    

+    // Test resize

+    resize_view(&view, 1024, 768);

+    

+    TEST_ASSERT_EQ(1024, view.windowWidth, "Window width should be updated");

+    TEST_ASSERT_EQ(768, view.windowHeight, "Window height should be updated");

+    

+    // Test with zero dimensions (should be handled gracefully)

+    resize_view(&view, 0, 0);

+    TEST_ASSERT(view.windowWidth > 0, "Window width should remain positive");

+    TEST_ASSERT(view.windowHeight > 0, "Window height should remain positive");

+    

+    TEST_END();

+}

+

+// Main test runner

+int main() {

+    printf(BLUE "=== View Management Unit Tests ===" RESET "\n\n");

+    

+    RUN_TEST(test_view_initialization);

+    RUN_TEST(test_coordinate_transformations);

+    RUN_TEST(test_zoom_functionality);

+    RUN_TEST(test_panning_functionality);

+    RUN_TEST(test_view_fitting);

+    RUN_TEST(test_clustering);

+    RUN_TEST(test_view_reset);

+    RUN_TEST(test_window_resize);

+    

+    TEST_SUMMARY();

+}
\ No newline at end of file