docs: Add documentation for Process module tests

- Added documentation for the new Process module tests, including
  details on test structure, execution, and individual test
  descriptions.
- Created new documentation files for Process module tests.
- Updated the main Rhai documentation index to include the new
  Process module tests.

src/rhai_tests/process/01_command_execution.rhai

@@ -0,0 +1,61 @@
+// 01_command_execution.rhai
+// Tests for command execution in the Process module
+
+// Custom assert function
+fn assert_true(condition, message) {
+    if !condition {
+        print(`ASSERTION FAILED: ${message}`);
+        throw message;
+    }
+}
+
+print("=== Testing Basic Command Execution ===");
+
+// Test running a simple command
+print("Testing run() with a simple command...");
+let result = run("echo Hello, World!").execute();
+assert_true(result.success, "Command should succeed");
+assert_true(result.stdout.contains("Hello, World!"), "Command output should contain the expected text");
+print(`✓ run().execute(): Command executed successfully`);
+
+// Test running a command with arguments
+print("Testing run() with command arguments...");
+let result_with_args = run("echo Hello from Rhai tests").execute();
+assert_true(result_with_args.success, "Command with arguments should succeed");
+assert_true(result_with_args.stdout.contains("Hello from Rhai tests"), "Command output should contain the expected text");
+print(`✓ run().execute(): Command with arguments executed successfully`);
+
+// Test running a command with environment variables
+print("Testing run() with environment variables...");
+let env_result = run("echo $HOME").execute();
+assert_true(env_result.success, "Command with environment variables should succeed");
+assert_true(env_result.stdout.trim() != "", "Environment variable should be expanded");
+print(`✓ run().execute(): Command with environment variables executed successfully`);
+
+// Test running a multiline script
+print("Testing run() with a multiline script...");
+let script_result = run(`
+    echo "Line 1"
+    echo "Line 2"
+    echo "Line 3"
+`).execute();
+assert_true(script_result.success, "Multiline script should succeed");
+assert_true(script_result.stdout.contains("Line 1") && script_result.stdout.contains("Line 2") && script_result.stdout.contains("Line 3"),
+           "Script output should contain all lines");
+print(`✓ run().execute(): Multiline script executed successfully`);
+
+// Test which function
+print("Testing which() function...");
+let bash_path = which("bash");
+assert_true(bash_path != "", "bash should be found in PATH");
+print(`✓ which(): Found bash at ${bash_path}`);
+
+// Test a command that doesn't exist
+let nonexistent_cmd = which("this_command_does_not_exist_12345");
+if nonexistent_cmd == "" {
+    print(`✓ which(): Correctly reported that nonexistent command was not found`);
+} else {
+    print(`Note: Unexpectedly found command at ${nonexistent_cmd}`);
+}
+
+print("All command execution tests completed successfully!");

src/rhai_tests/process/02_process_management.rhai

@@ -0,0 +1,54 @@
+// 02_process_management.rhai
+// Tests for process management functions in the Process module
+
+// Custom assert function
+fn assert_true(condition, message) {
+    if !condition {
+        print(`ASSERTION FAILED: ${message}`);
+        throw message;
+    }
+}
+
+print("=== Testing Process Management Functions ===");
+
+// Test process_list function
+print("Testing process_list() function...");
+let all_processes = process_list("");
+assert_true(all_processes.len() > 0, "There should be at least one running process");
+print(`✓ process_list(): Found ${all_processes.len()} processes`);
+
+// Test process properties
+print("Testing process properties...");
+let first_process = all_processes[0];
+assert_true(first_process.pid > 0, "Process PID should be a positive number");
+assert_true(first_process.name.len() > 0, "Process name should not be empty");
+print(`✓ Process properties: PID=${first_process.pid}, Name=${first_process.name}, CPU=${first_process.cpu}%, Memory=${first_process.memory}`);
+
+// Test process_list with a pattern
+print("Testing process_list() with a pattern...");
+// Use a pattern that's likely to match at least one process on most systems
+let pattern = "sh";
+let matching_processes = process_list(pattern);
+print(`Found ${matching_processes.len()} processes matching '${pattern}'`);
+if (matching_processes.len() > 0) {
+    let matched_process = matching_processes[0];
+    print(`✓ process_list(pattern): Found process ${matched_process.name} with PID ${matched_process.pid}`);
+} else {
+    print(`Note: No processes found matching '${pattern}'. This is not necessarily an error.`);
+}
+
+// Test process_get function
+// Note: We'll only test this if we found matching processes above
+if (matching_processes.len() == 1) {
+    print("Testing process_get() function...");
+    let process = process_get(pattern);
+    assert_true(process.pid > 0, "Process PID should be a positive number");
+    assert_true(process.name.contains(pattern), "Process name should contain the pattern");
+    print(`✓ process_get(): Found process ${process.name} with PID ${process.pid}`);
+} else {
+    print("Skipping process_get() test as it requires exactly one matching process");
+}
+
+// Note: We won't test the kill function as it could disrupt the system
+
+print("All process management tests completed successfully!");

src/rhai_tests/process/run_all_tests.rhai

@@ -0,0 +1,76 @@
+// run_all_tests.rhai
+// Runs all Process module tests
+
+print("=== Running Process Module Tests ===");
+
+// Custom assert function
+fn assert_true(condition, message) {
+    if !condition {
+        print(`ASSERTION FAILED: ${message}`);
+        throw message;
+    }
+}
+
+// Run each test directly
+let passed = 0;
+let failed = 0;
+
+// Test 1: Command Execution
+print("\n--- Running Command Execution Tests ---");
+try {
+    // Test running a simple command
+    print("Testing run() with a simple command...");
+    let result = run("echo Hello, World!").execute();
+    assert_true(result.success, "Command should succeed");
+    assert_true(result.stdout.contains("Hello, World!"), "Command output should contain the expected text");
+    print(`✓ run().execute(): Command executed successfully`);
+
+    // Test which function
+    print("Testing which() function...");
+    let bash_path = which("bash");
+    assert_true(bash_path != "", "bash should be found in PATH");
+    print(`✓ which(): Found bash at ${bash_path}`);
+
+    print("--- Command Execution Tests completed successfully ---");
+    passed += 1;
+} catch(err) {
+    print(`!!! Error in Command Execution Tests: ${err}`);
+    failed += 1;
+}
+
+// Test 2: Process Management
+print("\n--- Running Process Management Tests ---");
+try {
+    // Test process_list function
+    print("Testing process_list() function...");
+    let all_processes = process_list("");
+    assert_true(all_processes.len() > 0, "There should be at least one running process");
+    print(`✓ process_list(): Found ${all_processes.len()} processes`);
+
+    // Test process properties
+    print("Testing process properties...");
+    let first_process = all_processes[0];
+    assert_true(first_process.pid > 0, "Process PID should be a positive number");
+    assert_true(first_process.name.len() > 0, "Process name should not be empty");
+    print(`✓ Process properties: PID=${first_process.pid}, Name=${first_process.name}`);
+
+    print("--- Process Management Tests completed successfully ---");
+    passed += 1;
+} catch(err) {
+    print(`!!! Error in Process Management Tests: ${err}`);
+    failed += 1;
+}
+
+print("\n=== Test Summary ===");
+print(`Passed: ${passed}`);
+print(`Failed: ${failed}`);
+print(`Total: ${passed + failed}`);
+
+if failed == 0 {
+    print("\n✅ All tests passed!");
+} else {
+    print("\n❌ Some tests failed!");
+}
+
+// Return the number of failed tests (0 means success)
+failed;