Test Support for File/executable paths (#467)

* Add more unit tests

* GHA: Retrigger tests

* Add exit(1)

* Fix broken tests.

- Modified name for file open'd in open.c
- Move fork.c to non-deterministic, remove it from skip list.
- Print argv[0] in hello-arg
- Run correct hello binary in forkexecv-arg.c

* Merge main to resolve conflicts

* Add execv-arg to skip list

* Add open to skip list

* Adding test support for exec, open and hello-arg tests

* Ensure LIND_FS_ROOT exists in CI environment

* Fix CI path resolution with symlink in Docker

* Code enhacments, Reverting symlink in docker e2e and removed a bunch of tests in skip list

* adding symlink back again due to CI failure

* Removing all skip test cases

* Finalized the skip list

* Modified regex for analyzing wide range of dependencies

* Adding readlinkat and creat_access to the skip list

---------

Co-authored-by: Alice W <[email protected]>
Co-authored-by: Sanchit Sahay <[email protected]>
Co-authored-by: Nicholas Renner <[email protected]>

Author: 4 people

Docker/Dockerfile.e2e

@@ -112,6 +112,8 @@ RUN install -D -m 0755 /scripts/lind_compile /usr/local/bin/lind_compile \
 # Run all tests, print results, and exit with 1, if any test fails; 0 otherwise
 FROM base AS test
 COPY --parents scripts tests tools skip_test_cases.txt Makefile .
+# Create symlink so hardcoded paths in wasmtime match Docker environment
+RUN mkdir -p /home/lind && ln -sf / /home/lind/lind-wasm
 # NOTE: Build artifacts from prior stages are only mounted, to save COPY time
 # and cache layers. This means they are not preserved in the resulting image.
 RUN --mount=from=build-wasmtime,source=src/wasmtime/target,destination=src/wasmtime/target \

scripts/wasmtestreport.py

@@ -16,6 +16,7 @@
 import os
 import subprocess
 from pathlib import Path
+from typing import Dict
 import argparse
 import shutil
 import logging
@@ -42,6 +43,7 @@
 REPO_ROOT = SCRIPT_DIR.parent
 LIND_WASM_BASE = Path(os.environ.get("LIND_WASM_BASE", REPO_ROOT)).resolve()
 LIND_FS_ROOT = Path(os.environ.get("LIND_FS_ROOT", LIND_WASM_BASE / "src/RawPOSIX/tmp")).resolve()
+CC = os.environ.get("CC", "gcc")  # C compiler, defaults to gcc
 
 LIND_TOOL_PATH = LIND_WASM_BASE / "scripts"
 TEST_FILE_BASE = LIND_WASM_BASE / "tests" / "unit-tests"
@@ -63,7 +65,7 @@
     "Lind_wasm_Segmentation_Fault": "Lind Wasm Segmentation Failure",
     "Lind_wasm_Timeout": "Timeout During Lind Wasm run",
     "Unknown_Failure": "Unknown Failure",
-    "Output_mismatch": "GCC and Wasm Output mismatch"
+    "Output_mismatch": "C Compiler and Wasm Output mismatch"
     }
 
 # ----------------------------------------------------------------------
@@ -223,16 +225,42 @@ def compile_and_run_native(source_file, timeout_sec=DEFAULT_TIMEOUT):
     source_file = Path(source_file)
     native_output = source_file.parent / f"{source_file.stem}.o"
 
+    # Prepare any executable dependencies required by this test (like execv targets)
+    executable_backups: Dict[Path, Path] = {}
+    created_native_execs = set()
+    native_dependencies = analyze_executable_dependencies([source_file])
+    for exec_path, dependency_source in native_dependencies.items():
+        dest_path = (LIND_FS_ROOT / exec_path).resolve()
+        dest_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if dest_path.exists():
+            fd, backup_path = tempfile.mkstemp(prefix=f"{dest_path.name}_orig_", dir=str(dest_path.parent))
+            os.close(fd)
+            shutil.copy2(str(dest_path), backup_path)
+            executable_backups[dest_path] = Path(backup_path)
+
+        dep_compile_cmd = [CC, str(dependency_source), "-o", str(dest_path)]
+        try:
+            dep_proc = run_subprocess(dep_compile_cmd, label="native dep compile", shell=False)
+        except Exception as e:
+            return False, f"Exception compiling dependency {dependency_source}: {e}", "compile_error", "Failure_native_compiling"
+
+        if dep_proc.returncode != 0:
+            error_output = dep_proc.stdout + dep_proc.stderr
+            return False, f"Failed to compile dependency {dependency_source}: {error_output}", "compile_error", "Failure_native_compiling"
+
+        created_native_execs.add(dest_path)
+
     # Ensure paths are absolute to prevent cwd confusion
     if not source_file.is_absolute():
         raise ValueError(f"Source file must be absolute path, got: {source_file}")
     if not native_output.is_absolute():
         raise ValueError(f"Native output path must be absolute, got: {native_output}")
 
     # Compile
-    compile_cmd = ["gcc", str(source_file), "-o", str(native_output)]
+    compile_cmd = [CC, str(source_file), "-o", str(native_output)]
     try:
-        proc = run_subprocess(compile_cmd, label="gcc compile", cwd=LIND_FS_ROOT, shell=False)
+        proc = run_subprocess(compile_cmd, label=f"{CC} compile", cwd=LIND_FS_ROOT, shell=False)
         if proc.returncode != 0:
             return False, proc.stdout + proc.stderr, "compile_error", "Failure_native_compiling"
     except Exception as e:
@@ -251,8 +279,21 @@ def compile_and_run_native(source_file, timeout_sec=DEFAULT_TIMEOUT):
         return False, f"Exception: {e}", "unknown_error", "Failure_native_running"
     finally:
         # Clean up native binary
-        if native_output.exists():
-            native_output.unlink()
+        native_output.unlink(missing_ok=True)
+
+        # Restore any executable dependencies that were swapped out
+        for dest_path in created_native_execs:
+            try:
+                dest_path.unlink(missing_ok=True)
+            except (FileNotFoundError, PermissionError) as cleanup_err:
+                logger.debug(f"Failed to remove native dependency {dest_path}: {cleanup_err}")
+
+        for dest_path, backup_path in executable_backups.items():
+            try:
+                if backup_path.exists():
+                    shutil.move(str(backup_path), str(dest_path))
+            except (FileNotFoundError, PermissionError) as restore_err:
+                logger.warning(f"Failed to restore dependency {dest_path} from backup: {restore_err}")
 
 # ----------------------------------------------------------------------
 # Function: get_expected_output
@@ -474,8 +515,8 @@ def analyze_testfile_dependencies(tests_to_run):
             with open(test_file, 'r') as f:
                 content = f.read()
 
-            # Look for testfiles references in open() calls
-            testfile_pattern = r'open\s*\(\s*"testfiles/([^"]+)"'
+            # Look for any "testfiles/..." string literals in the code
+            testfile_pattern = r'"testfiles/([^"]+)"'
             matches = re.findall(testfile_pattern, content, re.IGNORECASE)
             all_dependencies.update(matches)
 
@@ -487,6 +528,102 @@ def analyze_testfile_dependencies(tests_to_run):
 
     return all_dependencies
 
+# ----------------------------------------------------------------------
+# Function: analyze_executable_dependencies
+#
+# Purpose:
+#   Analyzes test files to determine which executables they need
+#
+# Variables:
+# - Input:
+#   tests_to_run: List of test files to analyze
+# - Output:
+#   Dictionary mapping executable paths to their source file paths
+#   e.g., {'automated_tests/hello-arg': Path('hello-arg.c')}
+# ----------------------------------------------------------------------
+def analyze_executable_dependencies(tests_to_run):
+    import re
+    
+    executable_deps: Dict[str, Path] = {}
+    
+    for test_file in tests_to_run:
+        try:
+            with open(test_file, 'r') as f:
+                content = f.read()
+            
+            # Look for execv/execve/execl calls with string literal paths
+            # NOTE: This intentionally only matches simple string literals like execv("path", ...)
+            # It does NOT match variable references like execv(argv[0], ...) or macro expansions
+            # This is a deliberate limitation to keep the dependency analysis simple and predictable
+            # Pattern matches: execv("path/to/executable", ...), execl("/bin/ls", ...), etc.
+            exec_pattern = r'exec[vle]+\s*\(\s*"([^"]+)"'
+            matches = re.findall(exec_pattern, content, re.IGNORECASE)
+            
+            for exec_path in matches:
+                exec_name = Path(exec_path).name
+
+                candidate_sources = [
+                    test_file.parent / f"{exec_name}.c",
+                    test_file.resolve().parent / f"{exec_name}.c"
+                ]
+
+                selected_source = None
+                for candidate in candidate_sources:
+                    if candidate.exists():
+                        selected_source = candidate
+                        break
+
+                if selected_source:
+                    executable_deps[exec_path] = selected_source
+                    logger.debug(f"Found executable dependency in {test_file.name}: {exec_path} -> {selected_source.name}")
+                else:
+                    logger.debug(
+                        f"Executable {exec_path} referenced but no matching source found near {test_file}"
+                    )
+                
+        except Exception as e:
+            logger.debug(f"Could not analyze executable dependencies for {test_file}: {e}")
+    
+    return executable_deps
+
+# ----------------------------------------------------------------------
+# Function: create_required_executables
+#
+# Purpose:
+#   Compiles required executables and places them in LIND_FS_ROOT
+#
+# Variables:
+# - Input:
+#   executable_deps: Dictionary mapping executable paths to source files
+# - Output:
+#   None (creates executables in LIND_FS_ROOT)
+# ----------------------------------------------------------------------
+def create_required_executables(executable_deps):
+    if not executable_deps:
+        return
+    
+    logger.info(f"Creating {len(executable_deps)} required executable(s)")
+    
+    for exec_path, source_file in executable_deps.items():
+        try:
+            # Compile the source file to WASM
+            wasm_file, compile_err = compile_c_to_wasm(source_file)
+            
+            if wasm_file is None:
+                logger.error(f"Failed to compile {source_file}: {compile_err}")
+                continue
+            
+            # Create destination directory in LIND_FS_ROOT
+            dest_path = LIND_FS_ROOT / exec_path
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Copy the compiled WASM to the destination (preserves source for potential reuse)
+            shutil.copy2(str(wasm_file), str(dest_path))
+            logger.info(f"Created executable: {dest_path}")
+            
+        except Exception as e:
+            logger.error(f"Failed to create executable {exec_path}: {e}")
+
 # ----------------------------------------------------------------------
 # Function: pre_test
 #
@@ -502,6 +639,9 @@ def analyze_testfile_dependencies(tests_to_run):
 #   None
 # ----------------------------------------------------------------------
 def pre_test(tests_to_run=None):
+    # Ensure LIND_FS_ROOT exists (For CI Environment)
+    os.makedirs(LIND_FS_ROOT, exist_ok=True)
+    
     # If tests_to_run is provided, use selective copying
     if tests_to_run:
         all_dependencies = analyze_testfile_dependencies(tests_to_run)
@@ -548,6 +688,11 @@ def pre_test(tests_to_run=None):
         except OSError:
             # Fallback to copying in case symlink creation fails
             shutil.copy2(readlinkfile_path, symlink_path)
+    
+    # Create required executables
+    if tests_to_run:
+        executable_deps = analyze_executable_dependencies(tests_to_run)
+        create_required_executables(executable_deps)
 
 # ----------------------------------------------------------------------
 # Function: generate_html_report

skip_test_cases.txt

@@ -1,31 +1,13 @@
 file_tests/deterministic/dup2.c
 file_tests/deterministic/dup3.c
-file_tests/deterministic/chmod.c
 file_tests/deterministic/cloexec.c
-file_tests/deterministic/close.c
-file_tests/deterministic/creat_access.c
-file_tests/deterministic/fchmod.c
-file_tests/deterministic/fcntl.c
-file_tests/deterministic/fdatasync.c
 file_tests/deterministic/flock.c
-file_tests/deterministic/fstat.c
-file_tests/deterministic/fsync.c
-file_tests/deterministic/mkdir_rmdir.c
 file_tests/deterministic/popen.c
-file_tests/deterministic/pread_pwrite.c
-file_tests/deterministic/readbytes.c
-file_tests/deterministic/readlink.c
+file_tests/deterministic/creat_access.c
 file_tests/deterministic/readlinkat.c
-file_tests/deterministic/rename.c
-file_tests/deterministic/stat.c
-file_tests/deterministic/sync_file_range.c
-file_tests/deterministic/truncate.c
-file_tests/deterministic/unlinkat.c
 file_tests/non-deterministic/sc-writev.c
 memory_tests/deterministic/mmap-negative1.c
 memory_tests/deterministic/mmap-negative2.c
-memory_tests/deterministic/mmap_complicated.c
-memory_tests/deterministic/mmap_file.c
 memory_tests/deterministic/mmaptest.c
 networking_tests/deterministic/uds-getsockname.c
 networking_tests/deterministic/uds-nb-select.c

tests/unit-tests/file_tests/deterministic/open.c

@@ -0,0 +1,22 @@
+/*
+* Before running this test:
+*   1. Create a file named "testfile.txt" in the $LIND_FS_ROOT directory.
+*/
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+
+int main() {
+    int fd = open("testfiles/filetestfile.txt", O_RDONLY);  
+
+    if (fd == -1) {
+        perror("open failed");
+        return 1;
+    }
+
+    printf("File opened successfully with fd = %d\n", fd);
+
+    close(fd);
+    return 0;
+}

tests/unit-tests/process_tests/deterministic/forkexecv-arg.c

@@ -0,0 +1,30 @@
+/*
+* Before running this test:
+*   1. Make sure to compile the target program (hello) using your desired toolchain.
+*   2. Copy the compiled binary to $LIND_FS_ROOT.
+*   3. IMPORTANT: Rename the binary to "hello-arg" (no .wasm or other extensions).
+*
+* The executable must be accessible at: $LIND_FS_ROOT/hello-arg
+*/
+
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+
+int main() {
+    pid_t pid = fork();
+
+    if (pid == 0) {
+        // child process: call execv with argument
+        char *args[] = {"hello-arg", "hello_from_parent", NULL};
+        execv("automated_tests/hello-arg", args);
+        perror("execv failed");  // only runs if execv fails
+        exit(1);
+    } else {
+        // parent process
+        wait(NULL);  // wait for child to finish
+    }
+
+    return 0;
+}

tests/unit-tests/process_tests/deterministic/forkexecv.c

@@ -1,8 +1,15 @@
+/*
+* Before running this test:
+*   1. Make sure to compile the target program (hello) using your desired toolchain.
+*   2. Copy the compiled binary to $LIND_FS_ROOT.
+*   3. IMPORTANT: Rename the binary to "hello" (no .wasm or other extensions).
+*
+* The executable must be accessible at: $LIND_FS_ROOT/hello
+*/
+
 #include <sys/types.h>
 #include <unistd.h>
 #include <stdio.h>
-
-#include <sys/types.h>
 #include <sys/wait.h>
 
 int main(void)

tests/unit-tests/process_tests/deterministic/hello-arg.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+    // Command line inputs arent currently supported by the test harness.
+    /*
+    if (argc < 2) {
+        printf("Usage: %s <your_argument>\n", argv[0]);
+        return 1;
+    }
+    */
+    argv[0] = "hello-arg";
+    printf("Received argument: %s\n", argv[0]);
+    return 0;
+}