cleanup: PR comments

Author: baalimago

README.md

@@ -84,10 +84,10 @@ Buildscripts to build numpy and other wheels for wasix. For convenience, this pa
 
 The build script is controlled by the following environment variables:
 
-- `CC`, `CXX`, `AR`, `LD`, `RANLIB`, etc... : The cross-compiler tools. These should all be normal clang tools, but target wasm32-wasix by default and use the wasix sysroot.
-- `WASIX_SYSROOT`: The path to the wasix sysroot that is used by the toolchain. Libraries will get installed here when you run `make install` or when they are required to build a package.
-- `INSTALL_DIR`: The path to the python library path. Wheels will get installed here when you run `make install`.
-- `WASMER`: The path to the wasmer binary. You must have it registered to handle wasm files as binfmt_misc. You can do this with `sudo $WASMER binfmt reregister`.
+* `CC`, `CXX`, `AR`, `LD`, `RANLIB`, etc... : The cross-compiler tools. These should all be normal clang tools, but target wasm32-wasix by default and use the wasix sysroot.
+* `WASIX_SYSROOT`: The path to the wasix sysroot that is used by the toolchain. Libraries will get installed here when you run `make install` or when they are required to build a package.
+* `INSTALL_DIR`: The path to the python library path. Wheels will get installed here when you run `make install`.
+* `WASMER`: The path to the wasmer binary. You must have it registered to handle wasm files as binfmt_misc. You can do this with `sudo $WASMER binfmt reregister`.
 
 The easiest way to setup all the environment variables is to activate the wasix-clang environment using `source wasix-clang/activate`.
 
@@ -339,7 +339,7 @@ to check which python libraries depend on shared libs. We try to keep that to a
 
 ### Structure
 
-<!--
+<!-- 
 There is the pkgs folder that contains most stuff
 
 For each project that can be built there are multiple files depending on the type.
@@ -365,52 +365,52 @@ TODO: Make this more understandable
 
 Inside the pkgs/ folder there can be the following directories:
 
-- `*.source`: clean submodule checkout
-- `*.prepared`: patched worktree of source
-- `*.build`: temporary build directory
-- `*.tar.gz`: python sdist
-- `*.sdist`: unpacked python sdist
-- `*.whl`: compiled python wheel
-- `*.wheel`: unpacked python wheel
-- `*.lib`: unpacked library/application
-- `*.tar.xz`: packed library/application
+* `*.source`: clean submodule checkout
+* `*.prepared`: patched worktree of source
+* `*.build`: temporary build directory
+* `*.tar.gz`: python sdist
+* `*.sdist`: unpacked python sdist
+* `*.whl`: compiled python wheel
+* `*.wheel`: unpacked python wheel
+* `*.lib`: unpacked library/application
+* `*.tar.xz`: packed library/application
 
 #### Base structure
 
 Each project follows a consistent flow through the first three main directories.
 
-- `*.source`
-  - This is a clean checkout of the project's upstream source code, tracked as a git submodule.
-  - We avoid modifying this directly, since changes here would slow down git operations in the build-scripts repo.
-- `*.prepared`
-  - A git worktree created from the `*.source` repository.
-  - If patches are needed, they're applied here.
-  - If no patches are needed, it's just a clean mirror of the source.
-  - This directory is persistent and only refreshed if the source changes so new patches can be developed in this directory
-- `*.build`
-  - A copy of the `*.prepared` directory, used for the actual build step.
-  - Contains all intermediate build artifacts.
-  - This directory is temporary and may be deleted between builds. Never make manual changes here.
+* `*.source`
+  * This is a clean checkout of the project's upstream source code, tracked as a git submodule.
+  * We avoid modifying this directly, since changes here would slow down git operations in the build-scripts repo.
+* `*.prepared`
+  * A git worktree created from the `*.source` repository.
+  * If patches are needed, they're applied here.
+  * If no patches are needed, it's just a clean mirror of the source.
+  * This directory is persistent and only refreshed if the source changes so new patches can be developed in this directory
+* `*.build`
+  * A copy of the `*.prepared` directory, used for the actual build step.
+  * Contains all intermediate build artifacts.
+  * This directory is temporary and may be deleted between builds. Never make manual changes here.
 
 The remaining steps are different depending on the type of project.
 
 #### Python modules
 
-- The build step creates a `*.tar.gz` sdist from the `*.build` directory.
-- The sdist is then extracted into a `*.sdist` folder.
-- Finally, a wheel (`*.whl`) is built from the `*.sdist`.
-- If you want to you can make a `*.wheel` directory to view the unpacked wheel
+* The build step creates a `*.tar.gz` sdist from the `*.build` directory.
+* The sdist is then extracted into a `*.sdist` folder.
+* Finally, a wheel (`*.whl`) is built from the `*.sdist`.
+* If you want to you can make a `*.wheel` directory to view the unpacked wheel
 
 #### WASIX libraries and applications
 
-- The build step builds the library and installs it into a `*.lib` folder, following the correct directory structure.
-- That folder is then compressed into a final distributable \*.tar.xz.
+* The build step builds the library and installs it into a `*.lib` folder, following the correct directory structure.
+* That folder is then compressed into a final distributable *.tar.xz.
 
 #### Interdependencies
 
 If a project depends on other project they can either be direct dependencies of that project or you can define a `*.sysroot` target with the dependencies as prerequisites.
 
-- `*.sysroot`
-  - Contains the merged builds of multiple other projects
-  - Useful when a project is using pkg-config to find its dependencies
-  - Automatically builds a sysroot from its list of prerequisites
+* `*.sysroot`
+  * Contains the merged builds of multiple other projects
+  * Useful when a project is using pkg-config to find its dependencies
+  * Automatically builds a sysroot from its list of prerequisites

run-tests.sh

@@ -0,0 +1,106 @@
+output_file=$(mktemp)
+
+PYTHON_PACKAGE=${1:-"python-with-packages"}
+
+# Set if a test that was not expected to fail did fail
+WORKING_FAILED=()
+BROKEN_FAILED=()
+WORKING_PASSED=()
+BROKEN_PASSED=()
+SKIPPED=()
+
+GREEN="\033[0;32m"
+RED="\033[0;31m"
+YELLOW="\033[0;33m"
+RESET="\033[0m"
+
+for testfile in tests/*.py; do
+    # Extract just the filename without path
+    TEST_NAME=$(basename "$testfile")
+
+    # Skip test if it is a *.skip.py file
+    if [[ "$TEST_NAME" == *.skip.py ]]; then
+        echo -e "${YELLOW}Skipping:${RESET} \033[1m$TEST_NAME${RESET}"
+        SKIPPED+=( "$TEST_NAME" )
+        continue
+    fi
+
+    EXPECT_BROKEN=false
+    if [[ "$TEST_NAME" == *-broken.py ]]; then
+        EXPECT_BROKEN=true
+    fi
+    
+    # Print colorful running message
+    echo -e "\033[0;34m▶ Running:${RESET} \033[1m$TEST_NAME${RESET}"
+    
+    # Run the test
+    $WASMER run --net --mapdir="/src:$(pwd)" --llvm $PYTHON_PACKAGE /src/$testfile
+    EXIT_CODE=$?
+
+    # Prepare output color. This will be changed depending on what we expect for the test
+    COLOR="$GREEN"
+    # Log result and prepare colorful outcome for later
+    if [ $EXIT_CODE -eq 0 ]; then
+        if $EXPECT_BROKEN; then
+            COLOR="${RED}"
+            BROKEN_PASSED+=( "$TEST_NAME" )
+        else
+            COLOR="${GREEN}"
+            WORKING_PASSED+=( "$TEST_NAME" )
+        fi
+        echo -e "  ${COLOR}✓ PASSED${RESET} $TEST_NAME" | tee -a "$output_file"
+    else
+        if $EXPECT_BROKEN; then
+            COLOR="${YELLOW}"
+            BROKEN_FAILED+=( "$TEST_NAME" )
+        else
+            COLOR="${RED}"
+            WORKING_FAILED+=( "$TEST_NAME" )
+        fi
+        echo -e "  ${COLOR}✗ FAILED${RESET} $TEST_NAME" | tee -a "$output_file"
+        echo -e "  ${COLOR}└── Test failed with exit code $EXIT_CODE${RESET}" | tee -a "$output_file"
+    fi
+    echo ""
+done
+
+# Check if all broken tests failed and all working tests passed
+EXPECTED_OUTCOME=false
+if [ ${#WORKING_FAILED[@]} -eq 0 ] && [ ${#BROKEN_PASSED[@]} -eq 0 ]; then
+    EXPECTED_OUTCOME=true
+fi
+
+BROKEN_TESTS=( ${BROKEN_FAILED[@]} ${BROKEN_PASSED[@]} )
+WORKING_TESTS=( ${WORKING_FAILED[@]} ${WORKING_PASSED[@]} )
+ALL_TESTS=( ${WORKING_FAILED[@]} ${WORKING_PASSED[@]} ${BROKEN_FAILED[@]} ${BROKEN_PASSED[@]} ${SKIPPED[@]} )
+
+
+# Print summary
+cat "$output_file"
+echo ""
+echo -e "\033[1;34mSummary:\033[0m"
+if $EXPECTED_OUTCOME; then
+    echo -e "  \033[0;32mAll tests behaved as expected!\033[0m"
+else
+    echo -e "  \033[0;31mSome tests did not behave as expected."
+fi
+
+if test ${#WORKING_FAILED[@]} -gt 0; then
+    echo -e "  ${RED}Failed tests (that were expected to pass):${RESET}"
+    for test in "${WORKING_FAILED[@]}"; do
+        echo -e "    $RED$test$RESET"
+    done
+fi
+if test ${#BROKEN_FAILED[@]} -gt 0; then
+    echo -e "  ${YELLOW}However ${#BROKEN_TESTS[@]} are marked broken. ${RESET}\033[4;5mGo fix the underlying issues.${RESET}"
+fi
+if test ${#BROKEN_WORKING[@]} -gt 0; then
+    echo -e "  ${RED}The following tests were marked broken but passed.${RESET}"
+    echo -e "  ${RED}Go mark them as not broken 🎉:${RESET}"
+    for test in "${BROKEN_WORKING[@]}"; do
+        echo -e "    $YELLOW$test$RESET"
+    done
+fi
+
+# Exit with the correct code
+$EXPECTED_OUTCOME
+

tests/conftest.py

@@ -1,10 +1,6 @@
 # test_protobuf_basic.py
 
-import os
-import sys
 import unittest
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from person_pb2 import Person
 
 
@@ -38,9 +34,7 @@ def test_clear_field(self):
     def test_unknown_field_ignored(self):
         # Protocol Buffers ignore unknown fields during deserialization.
         serialized = self.person.SerializeToString()
-        corrupted = (
-            serialized + b"\x20\x01"
-        )  # Append unknown field (field number 4, varint 1)
+        corrupted = serialized + b"\x20\x01"  # Append unknown field (field number 4, varint 1)
         new_person = Person()
         new_person.ParseFromString(corrupted)
         self.assertEqual(new_person.name, "Alice")
@@ -57,5 +51,5 @@ def test_repr_str(self):
         self.assertIn("id: 123", repr_str)
 
 
-if __name__ == "__main__":
-    unittest.main()
+if __name__ == '__main__':
+    unittest.main()

tests/protobuf-test.py

@@ -1,49 +1,41 @@
 import asyncio
-import pytest
 import uvloop
 
-# Install uvloop as the default event loop policy so asyncio.run uses it
+# Install uvloop as the default event loop policy
 asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
 
-
-# Internal async helpers (not collected directly by pytest)
-async def _sleep():
+async def test_sleep():
+    print("Testing asyncio.sleep...")
     await asyncio.sleep(0.1)
+    print("Passed: asyncio.sleep")
 
-
-async def _task_creation():
+async def test_task_creation():
+    print("Testing task creation...")
     async def dummy():
         await asyncio.sleep(0.01)
         return 42
 
     task = asyncio.create_task(dummy())
     result = await task
     assert result == 42, "Task did not return expected result"
+    print("Passed: task creation and execution")
 
+async def test_tcp_echo_server():
+    print("Testing TCP echo server...")
 
-async def _tcp_echo_server():
     async def handle_echo(reader, writer):
         data = await reader.read(100)
         writer.write(data)
         await writer.drain()
         writer.close()
 
-    # Use port 0 to avoid conflicts when running under pytest
-    try:
-        server = await asyncio.start_server(handle_echo, "127.0.0.1", 0)
-    except Exception as e:  # Network may be sandboxed/disabled
-        pytest.skip(f"Network unavailable for test: {e}")
-
-    if not server.sockets:
-        server.close()
-        await server.wait_closed()
-        pytest.skip("No sockets available (network sandbox)")
-
-    host, port = server.sockets[0].getsockname()[:2]
+    server = await asyncio.start_server(handle_echo, '127.0.0.1', 8888)
+    addr = server.sockets[0].getsockname()
+    print(f'Serving on {addr}')
 
     async def client():
-        reader, writer = await asyncio.open_connection(host, port)
-        message = b"hello"
+        reader, writer = await asyncio.open_connection('127.0.0.1', 8888)
+        message = b'hello'
         writer.write(message)
         await writer.drain()
         data = await reader.read(100)
@@ -54,27 +46,13 @@ async def client():
     await asyncio.gather(client(), return_exceptions=False)
     server.close()
     await server.wait_closed()
-
-
-# Pytest-compatible sync wrappers
-def test_sleep():
-    asyncio.run(_sleep())
-
-
-def test_task_creation():
-    asyncio.run(_task_creation())
-
-
-def test_tcp_echo_server():
-    asyncio.run(_tcp_echo_server())
-
+    print("Passed: TCP echo server")
 
 async def main():
-    await _sleep()
-    await _task_creation()
-    await _tcp_echo_server()
+    await test_sleep()
+    await test_task_creation()
+    await test_tcp_echo_server()
     print("✅ All uvloop tests passed.")
 
-
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())