full test params passing of exported functions

_demo/go/export/use/main.c

@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <inttypes.h>
+#include <assert.h>
 #include "../libexport.h"
 
 int main() {
@@ -43,26 +44,59 @@ int main() {
     // Test self-referential struct
     main_Node* node1 = CreateNode(100);
     main_Node* node2 = CreateNode(200);
-    LinkNodes(node1, node2);
+    int link_result = LinkNodes(node1, node2);
+    assert(link_result == 300);  // LinkNodes returns 100 + 200 = 300
+    printf("LinkNodes result: %d\n", link_result);
 
     int count = TraverseNodes(node1);
+    assert(count == 2);  // Should traverse 2 nodes
     printf("Node count: %d\n", count);
 
-    // Test basic types
-    printf("Bool: %d\n", ProcessBool(1));  // 1 for true
+    // Test basic types with assertions
+    assert(ProcessBool(1) == 0);  // ProcessBool(true) returns !true = false
+    printf("Bool: %d\n", ProcessBool(1));
+    
+    assert(ProcessInt8(10) == 11);  // ProcessInt8(x) returns x + 1
     printf("Int8: %d\n", ProcessInt8(10));
+    
+    assert(ProcessUint8(10) == 11);  // ProcessUint8(x) returns x + 1
     printf("Uint8: %d\n", ProcessUint8(10));
+    
+    assert(ProcessInt16(10) == 20);  // ProcessInt16(x) returns x * 2
     printf("Int16: %d\n", ProcessInt16(10));
+    
+    assert(ProcessUint16(10) == 20);  // ProcessUint16(x) returns x * 2
     printf("Uint16: %d\n", ProcessUint16(10));
+    
+    assert(ProcessInt32(10) == 30);  // ProcessInt32(x) returns x * 3
     printf("Int32: %d\n", ProcessInt32(10));
+    
+    assert(ProcessUint32(10) == 30);  // ProcessUint32(x) returns x * 3
     printf("Uint32: %u\n", ProcessUint32(10));
+    
+    assert(ProcessInt64(10) == 40);  // ProcessInt64(x) returns x * 4
     printf("Int64: %" PRId64 "\n", ProcessInt64(10));
+    
+    assert(ProcessUint64(10) == 40);  // ProcessUint64(x) returns x * 4
     printf("Uint64: %" PRIu64 "\n", ProcessUint64(10));
+    
+    assert(ProcessInt(10) == 110);  // ProcessInt(x) returns x * 11
     printf("Int: %ld\n", ProcessInt(10));
+    
+    assert(ProcessUint(10) == 210);  // ProcessUint(x) returns x * 21
     printf("Uint: %lu\n", ProcessUint(10));
+    
+    assert(ProcessUintptr(0x1000) == 4396);  // ProcessUintptr(x) returns x + 300 = 4096 + 300
     printf("Uintptr: %lu\n", ProcessUintptr(0x1000));
-    printf("Float32: %f\n", ProcessFloat32(3.14f));
-    printf("Float64: %f\n", ProcessFloat64(3.14));
+    
+    // Float comparisons with tolerance
+    float f32_result = ProcessFloat32(3.14f);
+    assert(f32_result > 4.7f && f32_result < 4.72f);  // ProcessFloat32(x) returns x * 1.5 ≈ 4.71
+    printf("Float32: %f\n", f32_result);
+    
+    double f64_result = ProcessFloat64(3.14);
+    assert(f64_result > 7.84 && f64_result < 7.86);  // ProcessFloat64(x) returns x * 2.5 ≈ 7.85
+    printf("Float64: %f\n", f64_result);
 
     // Test unsafe pointer
     int test_val = 42;
@@ -85,9 +119,30 @@ int main() {
     printf("Interface test skipped (complex in C)\n");
 
     // Test various parameter counts
+    assert(NoParams() == 42);  // NoParams() always returns 42
     printf("NoParams: %ld\n", NoParams());
+    
+    assert(OneParam(5) == 10);  // OneParam(x) returns x * 2
     printf("OneParam: %ld\n", OneParam(5));
+    
+    assert(ThreeParams(10, 2.5, 1) == 25.0);  // ThreeParams calculates result
     printf("ThreeParams: %f\n", ThreeParams(10, 2.5, 1));  // 1 for true
+    
+    // Test ProcessThreeUnnamedParams - now uses all parameters
+    GoString test_str = {"hello", 5};
+    double unnamed_result = ProcessThreeUnnamedParams(10, test_str, 1);
+    assert(unnamed_result == 22.5);  // (10 + 5) * 1.5 = 22.5
+    printf("ProcessThreeUnnamedParams: %f\n", unnamed_result);
+    
+    // Test ProcessWithVoidCallback - now returns int
+    int void_callback_result = ProcessWithVoidCallback(NULL);
+    assert(void_callback_result == 456);  // Returns 456 when callback is nil
+    printf("ProcessWithVoidCallback(NULL): %d\n", void_callback_result);
+    
+    // Test NoParamNames - function with unnamed parameters
+    int32_t no_names_result = NoParamNames(5, 10, 0);
+    assert(no_names_result == 789);  // Returns fixed value 789
+    printf("NoParamNames: %d\n", no_names_result);
 
     // Test XType from c package - create GoString for name parameter
     GoString xname = {"test_x", 6};  // name and length
@@ -116,6 +171,7 @@ int main() {
         {9, 10, 11, 12}
     };
     int32_t matrix_sum = ProcessMatrix2D(test_matrix);
+    assert(matrix_sum == 78);  // Sum of 1+2+3+...+12 = 78
     printf("Matrix2D sum: %d\n", matrix_sum);
     
     // Create a test 3D cube [2][3][4]uint8
@@ -129,6 +185,7 @@ int main() {
         }
     }
     uint32_t cube_sum = ProcessMatrix3D(test_cube);
+    assert(cube_sum == 300);  // Sum of 1+2+3+...+24 = 300
     printf("Matrix3D (cube) sum: %u\n", cube_sum);
     
     // Create a test 5x4 grid [5][4]double
@@ -141,6 +198,7 @@ int main() {
         }
     }
     double grid_sum = ProcessGrid5x4(test_grid);
+    assert(grid_sum == 115.0);  // Sum of 1.0+1.5+2.0+...+10.5 = 115.0
     printf("Grid5x4 sum: %f\n", grid_sum);
     
     // Test functions that return multidimensional arrays (as multi-level pointers)