Fix tests on windows, add javadoc

Author: svacas

native-lib/example_dataweave_module.py

@@ -23,52 +23,52 @@ def example_simple_functions():
     ok = True
 
     # Simple script execution
-    print("\n📝 Simple arithmetic:")
+    print("\n[*] Simple arithmetic:")
     script = "2 + 2"
     result = dataweave.run_script(script)
     ok = assert_result(script, result, "4") and ok
 
-    print("\n📝 Square root:")
+    print("\n[*] Square root:")
     script = "sqrt(144)"
     result = dataweave.run_script(script)
     ok = assert_result(script, result, "12") and ok
 
-    print("\n📝 Array operations:")
+    print("\n[*] Array operations:")
     script = "[1, 2, 3] map $ * 2"
     result = dataweave.run_script(script)
     ok = assert_result(script, result, "[\n  2, \n  4, \n  6\n]") and ok
 
-    print("\n📝 String operations:")
+    print("\n[*] String operations:")
     script = "upper('hello world')"
     result = dataweave.run_script(script)
     ok = assert_result(script, result, '"HELLO WORLD"') and ok
 
     # Script with inputs (simple values - auto-converted)
-    print("\n📝 Script with inputs (auto-converted):")
+    print("\n[*] Script with inputs (auto-converted):")
     script = "num1 + num2"
     result = dataweave.run_script(script, {"num1": 25, "num2": 17})
     ok = assert_result(script, result, "42") and ok
 
     # Script with complex inputs
-    print("\n📝 Script with complex object:")
+    print("\n[*] Script with complex object:")
     script = "payload.name"
     result = dataweave.run_script(script, {"payload": {"content": '{"name": "John", "age": 30}', "mimeType": "application/json"}})
     ok = assert_result(script, result, '"John"') and ok
 
     # Script with mixed input types
-    print("\n📝 Script with mixed input types:")
+    print("\n[*] Script with mixed input types:")
     script = "greeting ++ ' ' ++ payload.name"
     result = dataweave.run_script(script, {"greeting": "Hello", "payload": {"content": '{"name": "Alice", "role": "Developer"}', "mimeType": "application/json"}})
     ok = assert_result(script, result, '"Hello Alice"') and ok
 
     # Binary output
-    print("\n📝 Binary output:")
+    print("\n[*] Binary output:")
     script = "output application/octet-stream\n---\ndw::core::Binaries::fromBase64(\"holamund\")"
     result = dataweave.run_script(script)
     ok = assert_result(script, result, "holamund") and ok
 
     # Script with InputValue
-    print("\n📝 Inputs:")
+    print("\n[*] Inputs:")
     input_value = dataweave.InputValue(
         content="1234567",
         mimeType="application/csv",
@@ -80,7 +80,7 @@ def example_simple_functions():
 
     # Cleanup when done
     dataweave.cleanup()
-    print("\n✓ Cleanup completed")
+    print("\n[OK] Cleanup completed")
 
     return ok
 
@@ -89,9 +89,9 @@ def assert_result(script, result, expected):
     print(f"   {script} = {result}")
     ok = result.get_string() == expected
     if ok:
-        status = "✅"
+        status = "[OK]"
     else:
-        status = f"❌ (expected: {expected})"
+        status = f"[FAIL] (expected: {expected})"
     print(f"   result as string = {result.get_string()}  {status}")
     print(f"   result as bytes = {result.get_bytes()}")
     return ok
@@ -106,7 +106,7 @@ def example_context_manager():
     ok = True
 
     with dataweave.DataWeave() as dw:
-        print("\n📝 Multiple operations with same runtime:")
+        print("\n[*] Multiple operations with same runtime:")
 
         script = "2 + 2"
         result = dw.run(script)
@@ -120,7 +120,7 @@ def example_context_manager():
         result = dw.run(script, {"numbers": [1, 2, 3, 4, 5], "multiplier": 10})
         ok = assert_result(script, result, "[\n  10, \n  20, \n  30, \n  40, \n  50\n]") and ok
 
-    print("\n✓ Context manager automatically cleaned up resources")
+    print("\n[OK] Context manager automatically cleaned up resources")
 
     return ok
 
@@ -131,7 +131,7 @@ def example_explicit_format():
     print("Example 3: Explicit Format (Advanced)")
     print("="*70)
 
-    print("\n📝 Using explicit content and mimeType:")
+    print("\n[*] Using explicit content and mimeType:")
 
     ok = True
 
@@ -153,15 +153,15 @@ def example_error_handling():
     print("="*70)
 
     try:
-        print("\n📝 Invalid script (will show error):")
+        print("\n[*] Invalid script (will show error):")
         result = dataweave.run_script("invalid syntax here", {})
-        print(f"   Result: {result} {'✅' if result.success == False else '❌'}")
+        print(f"   Result: {result} {'[OK]' if result.success == False else '[FAIL]'}")
 
     except dataweave.DataWeaveLibraryNotFoundError as e:
-        print(f"❌ Library not found: {e}")
+        print(f"[ERROR] Library not found: {e}")
         print("   Please build the library first: ./gradlew nativeCompile")
     except dataweave.DataWeaveError as e:
-        print(f"❌ DataWeave error: {e}")
+        print(f"[ERROR] DataWeave error: {e}")
 
 
 def main():
@@ -181,17 +181,17 @@ def main():
 
         print("\n" + "="*70)
         if all_ok:
-            print("✓ All examples completed successfully!")
+            print("[OK] All examples completed successfully!")
         else:
-            print("✗ One or more examples failed")
+            print("[FAIL] One or more examples failed")
         print("="*70)
 
     except dataweave.DataWeaveLibraryNotFoundError as e:
-        print(f"\n❌ Error: {e}")
+        print(f"\n[ERROR] {e}")
         print("\nPlease build the native library first:")
         print("  ./gradlew nativeCompile")
     except Exception as e:
-        print(f"\n❌ Unexpected error: {e}")
+        print(f"\n[ERROR] Unexpected error: {e}")
         import traceback
         traceback.print_exc()
 

native-lib/python/tests/test_dataweave_module.py

@@ -17,10 +17,10 @@ def test_basic():
     try:
         result = dataweave.run_script("2 + 2", {})
         assert result.get_string() == "4", f"Expected '4', got '{result.get_string()}'"
-        print("✓ Basic script execution works")
+        print("[OK] Basic script execution works")
         return True
     except Exception as e:
-        print(f"✗ Basic script execution failed: {e}")
+        print(f"[FAIL] Basic script execution failed: {e}")
         return False
 
 def test_with_inputs():
@@ -29,10 +29,10 @@ def test_with_inputs():
     try:
         result = dataweave.run_script("num1 + num2", {"num1": 25, "num2": 17})
         assert result.get_string() == "42", f"Expected '42', got '{result.get_string()}'"
-        print("✓ Script with inputs works")
+        print("[OK] Script with inputs works")
         return True
     except Exception as e:
-        print(f"✗ Script with inputs failed: {e}")
+        print(f"[FAIL] Script with inputs failed: {e}")
         return False
 
 def test_context_manager():
@@ -45,10 +45,10 @@ def test_context_manager():
             assert result.get_string() == "12", f"Expected '12', got '{result.get_string()}'"
             result = dataweave.run_script("sqrt(10000)")
             assert result.get_string() == "100", f"Expected '100', got '{result.get_string()}'"
-            print("✓ Script execution witch context manager works")
+            print("[OK] Script execution witch context manager works")
             return True
     except Exception as e:
-        print(f"✗ Script execution witch context manager failed: {e}")
+        print(f"[FAIL] Script execution witch context manager failed: {e}")
         return False
 
 def test_encoding():
@@ -83,10 +83,10 @@ def test_encoding():
         assert "Billy" in out, f"Expected name 'Billy' in CSV, got: {out!r}"
         assert "31" in out, f"Expected age '31' in CSV, got: {out!r}"
 
-        print("✓ Encoding conversion works")
+        print("[OK] Encoding conversion works")
         return True
     except Exception as e:
-        print(f"✗ Encoding conversion failed: {e}")
+        print(f"[FAIL] Encoding conversion failed: {e}")
         return False
 
 def test_auto_conversion():
@@ -101,10 +101,10 @@ def test_auto_conversion():
         )
         assert result.get_string() == "1", f"Expected '1', got '{result.get_string()}'"
 
-        print("✓ Auto-conversion works")
+        print("[OK] Auto-conversion works")
         return True
     except Exception as e:
-        print(f"✗ Auto-conversion failed: {e}")
+        print(f"[FAIL] Auto-conversion failed: {e}")
         return False
 
 def main():
@@ -131,19 +131,19 @@ def main():
         print("="*70)
 
         if passed == total:
-            print("\n✓ All tests passed!")
+            print("\n[OK] All tests passed!")
             sys.exit(0)
         else:
-            print(f"\n✗ {total - passed} test(s) failed")
+            print(f"\n[FAIL] {total - passed} test(s) failed")
             sys.exit(1)
 
     except dataweave.DataWeaveLibraryNotFoundError as e:
-        print(f"\n❌ Error: {e}")
+        print(f"\n[ERROR] {e}")
         print("\nPlease build the native library first:")
         print("  ./gradlew nativeCompile")
         sys.exit(2)
     except Exception as e:
-        print(f"\n❌ Unexpected error: {e}")
+        print(f"\n[ERROR] Unexpected error: {e}")
         import traceback
         traceback.print_exc()
         sys.exit(1)

native-lib/src/main/java/org/mule/weave/lib/NativeLib.java

@@ -8,22 +8,21 @@
 
 import java.nio.charset.StandardCharsets;
 
+/**
+ * GraalVM native entry points exposed for FFI consumers.
+ *
+ * <p>This class provides C-callable functions to execute DataWeave scripts and to free the returned
+ * unmanaged strings.</p>
+ */
 public class NativeLib {
 
     /**
-     * TODO FIX documentation
      * Native method that executes a DataWeave script with inputs and returns the result.
      * Can be called from Python via FFI.
      *
-     * Example JSON format:
-     * {
-     *   "payload": {"content": "{\"field\": \"value\"}", "mimeType": "application/json"},
-     *   "vars": {"content": "test", "mimeType": "text/plain"}
-     * }
-     *
      * @param thread the isolate thread (automatically provided by GraalVM)
      * @param script the DataWeave script to execute (C string pointer)
-     * @param inputsJson JSON string containing the inputs map with content and mimeType for each binding
+     * @param inputsJson JSON string containing the inputs map with content (base64 encoded), mimeType, properties and charset for each binding
      * @return the script execution result (C string pointer)
      */
     @CEntryPoint(name = "run_script")
@@ -36,6 +35,12 @@ public static CCharPointer runDwScriptEncoded(IsolateThread thread, CCharPointer
         return toUnmanagedCString(result);
     }
 
+    /**
+     * Frees a C string previously returned by {@link #runDwScriptEncoded(IsolateThread, CCharPointer, CCharPointer)}.
+     *
+     * @param thread the isolate thread (automatically provided by GraalVM)
+     * @param pointer the pointer to the unmanaged C string to free; if null, this is a no-op
+     */
     @CEntryPoint(name = "free_cstring")
     public static void freeCString(IsolateThread thread, CCharPointer pointer) {
         if (pointer.isNull()) {

native-lib/src/main/java/org/mule/weave/lib/ScriptRuntime.java

@@ -16,10 +16,22 @@
 import java.nio.charset.Charset;
 import java.util.Base64;
 
+/**
+ * Singleton wrapper around a {@link DWScriptingEngine} used to compile and execute DataWeave scripts.
+ *
+ * <p>Execution results are returned as a JSON string containing a base64-encoded payload plus metadata
+ * (mime type, charset, and whether the result is binary). Errors are returned as a JSON string with
+ * {@code success=false} and an escaped error message.</p>
+ */
 public class ScriptRuntime {
 
     private static final ScriptRuntime INSTANCE = new ScriptRuntime();
 
+    /**
+     * Returns the singleton instance.
+     *
+     * @return the shared {@link ScriptRuntime}
+     */
     public static ScriptRuntime getInstance() {
         return INSTANCE;
     }
@@ -30,10 +42,26 @@ private ScriptRuntime() {
         engine = DWScriptingEngine.builder().build();
     }
 
+    /**
+     * Executes a DataWeave script with no input bindings.
+     *
+     * @param script the DataWeave script source
+     * @return a JSON string describing either the successful result or an error
+     */
     public String run(String script) {
         return run(script, null);
     }
 
+    /**
+     * Executes a DataWeave script with optional input bindings encoded as JSON.
+     *
+     * <p>The expected JSON structure maps binding names to an object containing {@code content}
+     * (base64), {@code mimeType}, optional {@code charset}, and optional {@code properties}.</p>
+     *
+     * @param script the DataWeave script source
+     * @param inputsJson JSON string encoding the input bindings map, or {@code null}
+     * @return a JSON string describing either the successful result or an error
+     */
     public String run(String script, String inputsJson) {
         ScriptingBindings bindings = parseJsonInputsToBindings(inputsJson);
         String[] inputs = bindings.bindingNames();
@@ -74,10 +102,6 @@ public String run(String script, String inputsJson) {
         }
     }
 
-    /**
-     * Simple JSON parser for input map without external dependencies.
-     * Expected format: {"name1": {"content": "value1", "mimeType": "type1", "charset": "charset1", "properties": {"prop1": "value1", "prop2": "value2"}}}
-     */
     private ScriptingBindings parseJsonInputsToBindings(String inputsJson) {
         ScriptingBindings bindings = new ScriptingBindings();