qemu testing

.github/workflows/CI-docs.yml

@@ -1,25 +0,0 @@
-name: CI-docs
-
-on:
-  pull_request:
-    paths:
-      - 'docs/**'
-      - '!docs/code/**'
-      - '.github/workflows/CI-docs.yml'
-
-jobs:
-  docs-src:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: '3.9'
-          cache: 'pip' # caching pip dependencies
-      - run: pip install -r docs/requirements.txt
-      - name: html
-        run: |
-          make -C docs html
-      - name: linkcheck
-        run: |
-          make -C docs linkcheck

.github/workflows/CI-sample.yml

@@ -1,33 +0,0 @@
-name: ci-sample
-
-on:
-  pull_request:
-    paths:
-      - '**'
-      - '!docs/**'
-      - '!.**'
-      - 'docs/code/**'
-      - '.github/workflows/CI-sample.yml'
-  push:
-    branches:
-      - v[0-9].*
-      - master
-
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [macos-latest, ubuntu-latest, windows-latest]
-    runs-on: ${{matrix.os}}
-    steps:
-      - uses: actions/checkout@v6
-      - name: setup
-        run: cmake -E make_directory ${{runner.workspace}}/libuv/docs/code/build
-      - name: configure
-        # you may like use Ninja on unix-like OS, but for windows, the only easy way is to use Visual Studio if you want Ninja
-        run: cmake ..
-        working-directory: ${{runner.workspace}}/libuv/docs/code/build
-      - name: build
-        run: cmake --build .
-        working-directory: ${{runner.workspace}}/libuv/docs/code/build

.github/workflows/CI-unix.yml

@@ -14,168 +14,60 @@ on:
       - master
 
 jobs:
-  build-linux:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: configure
-        run: |
-          ./autogen.sh
-          mkdir build
-          (cd build && ../configure)
-      - name: distcheck
-        run: |
-          make -C build distcheck
-
-  build-android:
-    runs-on: ubuntu-latest
-    env:
-      ANDROID_AVD_HOME: /root/.android/avd
-    steps:
-      - uses: actions/checkout@v6
-      - name: Envinfo
-        run: npx envinfo
-      - name: Enable KVM
-        run: |
-          echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
-          sudo udevadm control --reload-rules
-          sudo udevadm trigger --name-match=kvm
-      - name: Build and Test
-        uses: reactivecircus/android-emulator-runner@v2
-        with:
-          api-level: 30
-          arch: x86_64
-          target: google_apis
-          ram-size: 2048M
-          emulator-options: -no-audio -no-window -gpu off -no-boot-anim -netdelay none -netspeed full -writable-system -no-snapshot-save -no-snapshot-load -no-snapshot
-          disable-animations: true
-          script: |
-            echo "::group::Configure"
-            cmake -B build -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake -DCMAKE_BUILD_TYPE=Release -DANDROID_ABI="x86_64" -DANDROID_PLATFORM=android-30
-            echo "::endgroup::"
-
-            echo "::group::Build"
-            cmake --build build
-
-            ## Correct some ld bugs that cause problems with libuv tests
-            wget "https://github.com/termux/termux-elf-cleaner/releases/download/v2.2.1/termux-elf-cleaner" -P build
-            chmod a+x build/termux-elf-cleaner
-            build/termux-elf-cleaner --api-level 30 ./build/uv_run_tests
-            build/termux-elf-cleaner --api-level 30 ./build/uv_run_tests_a
-
-            adb shell "su 0 setenforce 0" # to allow some syscalls like link, chmod, etc.
-
-            ## Push the build and test fixtures to the device
-            adb push build /data/local/tmp
-            adb shell mkdir /data/local/tmp/build/test
-            adb push test/fixtures /data/local/tmp/build/test
-            echo "::endgroup::"
-
-            ## Run the tests
-            file build/uv_run_tests_a
-            adb shell "cd /data/local/tmp/build && env UV_TEST_TIMEOUT_MULTIPLIER=5 ./uv_run_tests_a"
-
-  build-macos:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [macos-14, macos-15, macos-15-intel]
-    steps:
-      - uses: actions/checkout@v6
-      - name: Envinfo
-        run: npx envinfo
-      - name: Disable Firewall
-        run: |
-          /usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate
-          sudo defaults write /Library/Preferences/com.apple.alf globalstate -int 0
-          /usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate
-      - name: Setup
-        run: |
-          brew install ninja automake libtool
-      - name: Configure
-        run: |
-          cmake -B build -DBUILD_TESTING=ON -G Ninja
-      - name: Build
-        run: |
-          cmake --build build
-          ls -lh
-      - name: platform_output
-        run: |
-          ./build/uv_run_tests platform_output
-      - name: platform_output_a
-        run: |
-          ./build/uv_run_tests_a platform_output
-      - name: Test
-        if: ${{ matrix.os == 'macos-15' || matrix.os == 'macos-15-intel' }}
-        run: |
-          cd build && sudo UV_RUN_AS_ROOT=1 ctest -V
-      - name: Test
-        if: ${{ matrix.os != 'macos-15' && matrix.os != 'macos-15-intel' }}
-        run: |
-          cd build && ctest -V
-      - name: Autotools configure
-        if: always()
-        run: |
-          ./autogen.sh
-          mkdir build-auto
-          (cd build-auto && ../configure)
-          make -C build-auto -j4
-
-  build-ios:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [macos-14, macos-15]
-    steps:
-      - uses: actions/checkout@v6
-      - name: Configure
-        run: |
-          cmake -B build-ios -GXcode -DCMAKE_SYSTEM_NAME:STRING=iOS -DCMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED:BOOL=NO -DCMAKE_CONFIGURATION_TYPES:STRING=Release
-      - name: Build
-        run: |
-          cmake --build build-ios
-          ls -lh build-ios
-
   build-cross-qemu:
     runs-on: ubuntu-24.04
-    name: build-cross-qemu-${{ matrix.config.target }}
+    name: build-cross-qemu-${{ matrix.config.arch }}
 
     strategy:
       fail-fast: false
       matrix:
         config:
-          - {target: arm,                 toolchain: gcc-arm-linux-gnueabi,       cc: arm-linux-gnueabi-gcc,      qemu: qemu-arm      }
+          - {arch: arm,       triple: arm-linux-gnueabi,          qemu: arm,      }
-          - {target: armhf,               toolchain: gcc-arm-linux-gnueabihf,     cc: arm-linux-gnueabihf-gcc,    qemu: qemu-arm      }
+          - {arch: armhf,     triple: arm-linux-gnueabihf,        qemu: arm,      }
-          - {target: aarch64,             toolchain: gcc-aarch64-linux-gnu,       cc: aarch64-linux-gnu-gcc,      qemu: qemu-aarch64  }
+          - {arch: aarch64,   triple: aarch64-linux-gnu,          qemu: aarch64,  }
-          - {target: riscv64,             toolchain: gcc-riscv64-linux-gnu,       cc: riscv64-linux-gnu-gcc,      qemu: qemu-riscv64  }
+          - {arch: riscv64,   triple: riscv64-linux-gnu,          qemu: riscv64,  }
-          - {target: ppc,                 toolchain: gcc-powerpc-linux-gnu,       cc: powerpc-linux-gnu-gcc,      qemu: qemu-ppc      }
+          - {arch: ppc,       triple: powerpc-linux-gnu,          qemu: ppc,      }
-          - {target: ppc64,               toolchain: gcc-powerpc64-linux-gnu,     cc: powerpc64-linux-gnu-gcc,    qemu: qemu-ppc64    }
+          - {arch: ppc64,     triple: powerpc64-linux-gnu,        qemu: ppc64,    }
-          - {target: ppc64le,             toolchain: gcc-powerpc64le-linux-gnu,   cc: powerpc64le-linux-gnu-gcc,  qemu: qemu-ppc64le  }
+          - {arch: ppc64le,   triple: powerpc64le-linux-gnu,      qemu: ppc64le,  }
-          - {target: s390x,               toolchain: gcc-s390x-linux-gnu,         cc: s390x-linux-gnu-gcc,        qemu: qemu-s390x    }
+          - {arch: s390x,     triple: s390x-linux-gnu,            qemu: s390x,    }
-          - {target: mips,                toolchain: gcc-mips-linux-gnu,          cc: mips-linux-gnu-gcc,         qemu: qemu-mips     }
+          - {arch: mips,      triple: mips-linux-gnu,             qemu: mips,     }
-          - {target: mips64,              toolchain: gcc-mips64-linux-gnuabi64,   cc: mips64-linux-gnuabi64-gcc,  qemu: qemu-mips64   }
+          - {arch: mips64,    triple: mips64-linux-gnuabi64,      qemu: mips64,   }
-          - {target: mipsel,              toolchain: gcc-mipsel-linux-gnu,        cc: mipsel-linux-gnu-gcc,       qemu: qemu-mipsel   }
+          - {arch: mipsel,    triple: mipsel-linux-gnu,           qemu: mipsel,   }
-          - {target: mips64el,            toolchain: gcc-mips64el-linux-gnuabi64, cc: mips64el-linux-gnuabi64-gcc,qemu: qemu-mips64el }
+          - {arch: mips64el,  triple: mips64el-linux-gnuabi64,    qemu: mips64el, }
-          - {target: arm (u64 slots),     toolchain: gcc-arm-linux-gnueabi,       cc: arm-linux-gnueabi-gcc,      qemu: qemu-arm      }
-          - {target: aarch64 (u64 slots), toolchain: gcc-aarch64-linux-gnu,       cc: aarch64-linux-gnu-gcc,      qemu: qemu-aarch64  }
-          - {target: ppc (u64 slots),     toolchain: gcc-powerpc-linux-gnu,       cc: powerpc-linux-gnu-gcc,      qemu: qemu-ppc      }
-          - {target: ppc64 (u64 slots),   toolchain: gcc-powerpc64-linux-gnu,     cc: powerpc64-linux-gnu-gcc,    qemu: qemu-ppc64    }
 
     steps:
       - uses: actions/checkout@v6
-      - name: Install qemu and ${{ matrix.config.toolchain }}
+      - name: Install qemu and gcc-${{ matrix.config.triple }}
         run: |
           sudo apt update
-          sudo apt install qemu-user qemu-user-binfmt ${{ matrix.config.toolchain }} -y
+          sudo apt install ninja-build qemu-user qemu-user-binfmt gcc-${{ matrix.config.triple }} patchelf -y
-      - name: Configure with ${{ matrix.config.cc }}
+          # QEMU developers have been arguing for years if they want to work around this glibc bug
+          # so we will just implement our own workaround for it
+          # https://bugs.launchpad.net/qemu/+bug/1701798
+          sudo mkdir -p /usr/${{ matrix.config.triple }}/etc
+          sudo touch /usr/${{ matrix.config.triple }}/etc/ld.so.cache
+      - name: Configure with ${{ matrix.config.triple }}
         run: |
-          cmake -B build -DBUILD_TESTING=ON -DQEMU=ON -DCMAKE_C_COMPILER=${{ matrix.config.cc }}
+          cmake -S . -B build -G Ninja -DQEMU=ON -DBUILD_TESTING=ON -DCMAKE_C_COMPILER=${{ matrix.config.triple }}-gcc -DCMAKE_BUILD_WITH_INSTALL_RPATH=TRUE -DCMAKE_INSTALL_PREFIX=$PWD/install
       - name: Build
         run: |
           cmake --build build
           ls -lh build
-      - name: Test
+      - name: Install
         run: |
-          ${{ matrix.config.qemu }} build/uv_run_tests_a
+          cmake --install build
+      - name: Modify for qemu
+        run: |
+          patchelf --set-interpreter /usr/${{ matrix.config.triple}}/lib/ld-linux*.so.* build/uv_run_tests
+          patchelf --set-interpreter /usr/${{ matrix.config.triple}}/lib/ld-linux*.so.* build/uv_run_tests_a
+          patchelf --add-rpath /usr/${{ matrix.config.triple}}/lib build/uv_run_tests
+          patchelf --add-rpath /usr/${{ matrix.config.triple}}/lib build/uv_run_tests_a
+      - name: Test
+        # Use explicit qemu to test it was compiled for the right arch
+        run: |
+          qemu-${{ matrix.config.qemu }} --version
+          qemu-${{ matrix.config.qemu }} build/uv_run_tests_a
+      - name: Test
+        if: always()
+        run: |
+          qemu-${{ matrix.config.qemu }} build/uv_run_tests

.github/workflows/CI-win.yml

@@ -1,128 +0,0 @@
-name: CI-win
-
-on:
-  pull_request:
-    paths:
-      - '**'
-      - '!docs/**'
-      - '!src/unix/**'
-      - '!.**'
-      - '.github/workflows/CI-win.yml'
-  push:
-    branches:
-      - v[0-9].*
-      - master
-
-jobs:
-  build-windows:
-    runs-on: windows-${{ matrix.config.server }}
-    name: build-${{ join(matrix.config.*, '-') }}
-    strategy:
-      fail-fast: false
-      matrix:
-        config:
-          - {toolchain: Visual Studio 17 2022, arch: Win32, server: 2022}
-          - {toolchain: Visual Studio 17 2022, arch: x64, server: 2022}
-          - {toolchain: Visual Studio 17 2022, arch: x64, server: 2022, config: ASAN}
-          - {toolchain: Visual Studio 17 2022, arch: x64, server: 2022, config: UBSAN}
-          - {toolchain: Visual Studio 17 2022, arch: arm64, server: 2022}
-          - {toolchain: Visual Studio 17 2022, arch: x64, server: 2025}
-    steps:
-      - uses: actions/checkout@v6
-      - name: Build
-        run:
-          cmake -S . -B build -DBUILD_TESTING=ON
-            -G "${{ matrix.config.toolchain }}" -A ${{ matrix.config.arch }}
-            ${{ matrix.config.config == 'ASAN' && '-DASAN=on -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded' || '' }}
-
-          cmake --build build --config RelWithDebInfo
-
-          ${{ matrix.config.config == 'ASAN' && 'Copy-Item -Path "build\\*.exe" -Destination "build\\RelWithDebInfo\\"' || '' }}
-
-          ${{ matrix.config.config == 'ASAN' && 'Copy-Item -Path "build\\*.dll" -Destination "build\\RelWithDebInfo\\"' || '' }}
-
-          ls -l build
-          
-          ls -l build\\RelWithDebInfo
-      - name: platform_output_a
-        if: ${{ matrix.config.arch != 'arm64' }}
-        shell: cmd
-        run:
-          build\\RelWithDebInfo\\uv_run_tests_a.exe platform_output
-      - name: platform_output
-        if: ${{ matrix.config.arch != 'arm64' }}
-        shell: cmd
-        run:
-          build\\RelWithDebInfo\\uv_run_tests.exe platform_output
-      - name: Test
-        # only valid with libuv-master with the fix for
-        # https://github.com/libuv/leps/blob/master/005-windows-handles-not-fd.md
-        if: ${{ matrix.config.config != 'ASAN' && matrix.config.arch != 'arm64' }}
-        shell: cmd
-        run:
-          cd build
-
-          ctest -C RelWithDebInfo -V
-      - name: Test only static
-        if: ${{ matrix.config.config == 'ASAN' && matrix.config.arch != 'arm64' }}
-        shell: cmd
-        run:
-          build\\RelWithDebInfo\\uv_run_tests_a.exe
-
-  build-mingw:
-    runs-on: ubuntu-latest
-    name: build-mingw-${{ matrix.config.arch }}
-    strategy:
-      fail-fast: false
-      matrix:
-        config:
-          - {arch: i686,   server: 2022, libgcc: dw2 }
-          - {arch: x86_64, server: 2022, libgcc: seh }
-    steps:
-      - uses: actions/checkout@v6
-      - name: Install mingw32 environment
-        run: |
-          sudo apt update
-          sudo apt install mingw-w64 ninja-build -y
-      - name: Build
-        run: |
-          cmake -B build -G Ninja -DHOST_ARCH=${{ matrix.config.arch }} -DBUILD_TESTING=ON -DCMAKE_TOOLCHAIN_FILE=cmake-toolchains/cross-mingw32.cmake
-          cmake --build build
-          cmake --install build --prefix "`pwd`/build/usr"
-          mkdir -p build/usr/test build/usr/bin
-          cp -av test/fixtures build/usr/test
-          cp -av build/uv_run_tests_a.exe build/uv_run_tests.exe build/uv_run_tests_a_no_ext build/uv_run_tests_no_ext \
-             `${{ matrix.config.arch }}-w64-mingw32-gcc -print-file-name=libgcc_s_${{ matrix.config.libgcc }}-1.dll` \
-             `${{ matrix.config.arch }}-w64-mingw32-gcc -print-file-name=libwinpthread-1.dll` \
-             `${{ matrix.config.arch }}-w64-mingw32-gcc -print-file-name=libatomic-1.dll` \
-             build/usr/bin
-      - name: Upload build artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: mingw-${{ matrix.config.arch }}
-          path: build/usr/**/*
-          retention-days: 2
-
-  test-mingw:
-    runs-on: windows-${{ matrix.config.server }}
-    name: test-mingw-${{ matrix.config.arch }}
-    needs: build-mingw
-    strategy:
-      fail-fast: false
-      matrix:
-        config:
-          - {arch: i686,   server: 2022}
-          - {arch: x86_64, server: 2022}
-    steps:
-      - name: Download build artifacts
-        uses: actions/download-artifact@v8
-        with:
-          name: mingw-${{ matrix.config.arch }}
-      - name: Test
-        shell: cmd
-        run: |
-          bin\uv_run_tests_a.exe
-      - name: Test
-        shell: cmd
-        run: |
-          bin\uv_run_tests.exe

.github/workflows/sanitizer.yml

@@ -1,104 +0,0 @@
-name: Sanitizer checks
-
-on:
-  pull_request:
-    paths:
-      - '**'
-      - '!docs/**'
-      - '!.**'
-      - '.github/workflows/sanitizer.yml'
-  push:
-    branches:
-      - v[0-9].*
-      - master
-
-jobs:
-  sanitizers-linux:
-    runs-on: ubuntu-22.04
-    strategy:
-      matrix:
-        config:
-          - name: ASAN
-            flags: -DASAN=ON -DCMAKE_BUILD_TYPE=Debug
-          - name: MSAN
-            flags: -DMSAN=ON -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=clang
-          - name: TSAN
-            flags: -DTSAN=ON -DCMAKE_BUILD_TYPE=Release
-          - name: UBSAN
-            flags: -DUBSAN=ON -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=clang
-    steps:
-      - uses: actions/checkout@v6
-      - name: Setup
-        run: |
-          sudo apt-get install ninja-build
-      - name: Envinfo
-        run: npx envinfo
-
-      # [AM]SAN fail on newer kernels due to a bigger PIE slide
-      - name: Disable ASLR
-        run: |
-          sudo sysctl -w kernel.randomize_va_space=0
-
-      - name: Build ${{ matrix.config.name }}
-        run: |
-          cmake -B build -G Ninja -DBUILD_TESTING=ON ${{ matrix.config.flags }}
-          cmake --build build
-
-      - name: Test ${{ matrix.config.name }}
-        run: |
-          # Note: path must be absolute because some tests chdir.
-          # TSan exits with an error when it can't find the file.
-          if [ "${{ matrix.config.name }}" = "TSAN" ]; then
-            env TSAN_OPTIONS="suppressions=$PWD/tsansupp.txt" ./build/uv_run_tests_a
-          else
-            ./build/uv_run_tests_a
-          fi
-
-  sanitizers-macos:
-    runs-on: macos-14
-    strategy:
-      matrix:
-        config:
-          - name: ASAN
-            flags: -DASAN=ON -DCMAKE_BUILD_TYPE=Debug
-          - name: TSAN
-            flags: -DTSAN=ON -DCMAKE_BUILD_TYPE=Release
-          - name: UBSAN
-            flags: -DUBSAN=ON -DCMAKE_BUILD_TYPE=Debug
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Envinfo
-        run: npx envinfo
-
-      - name: Build ${{ matrix.config.name }}
-        run: |
-          cmake -B build -DBUILD_TESTING=ON ${{ matrix.config.flags }}
-          cmake --build build
-      - name: Test ${{ matrix.config.name }}
-        run: ./build/uv_run_tests_a
-
-  sanitizers-windows:
-    runs-on: windows-2022
-    steps:
-      - uses: actions/checkout@v6
-      - name: Setup
-        run: |
-          choco install ninja
-
-      # Note: clang shipped with VS2022 has an issue where the UBSAN runtime doesn't link.
-      - name: Install LLVM and Clang
-        uses: KyleMayes/install-llvm-action@v2
-        with:
-          version: "17"
-
-      - name: Envinfo
-        run: npx envinfo
-
-      - name: UBSAN Build
-        run: |
-          cmake -B build-ubsan -G Ninja -DBUILD_TESTING=ON -DUBSAN=ON -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=clang
-          cmake --build build-ubsan
-      - name: UBSAN Test
-        run: |
-          ./build-ubsan/uv_run_tests_a

CMakeLists.txt

@@ -732,11 +732,7 @@ if(LIBUV_BUILD_TESTS)
   add_executable(uv_run_tests_a ${uv_test_sources} uv_win_longpath.manifest)
   target_compile_definitions(uv_run_tests_a PRIVATE ${uv_defines})
   target_compile_options(uv_run_tests_a PRIVATE ${uv_cflags})
-  if(QEMU)
+  target_link_libraries(uv_run_tests_a uv_a ${uv_test_libraries})
-    target_link_libraries(uv_run_tests_a uv_a ${uv_test_libraries} -static)
-  else()
-    target_link_libraries(uv_run_tests_a uv_a ${uv_test_libraries})
-  endif()
   add_test(NAME uv_test_a
            COMMAND uv_run_tests_a
            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

test/test-connection-fail.c

@@ -120,11 +120,6 @@ static void connection_fail(uv_connect_cb connect_cb) {
  * expect an error.
  */
 TEST_IMPL(connection_fail) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-
   connection_fail(on_connect_with_close);
 
   ASSERT_OK(timer_close_cb_calls);
@@ -141,11 +136,6 @@ TEST_IMPL(connection_fail) {
  * attempt.
  */
 TEST_IMPL(connection_fail_doesnt_auto_close) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-
   int r;
 
   r = uv_timer_init(uv_default_loop(), &timer);

test/test-get-currentexe.c

@@ -31,11 +31,6 @@
 extern char executable_path[];
 
 TEST_IMPL(get_currentexe) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-
   char buffer[PATHMAX];
   char path[PATHMAX];
   size_t size;

test/test-get-passwd.c

@@ -28,11 +28,6 @@
 #endif
 
 TEST_IMPL(get_passwd) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-
   uv_passwd_t pwd;
   size_t len;
   int r;

test/test-getaddrinfo.c

@@ -82,11 +82,6 @@ static void getaddrinfo_cuncurrent_cb(uv_getaddrinfo_t* handle,
 
 
 TEST_IMPL(getaddrinfo_fail) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-  
   uv_getaddrinfo_t req;
 
   ASSERT_EQ(UV_EINVAL, uv_getaddrinfo(uv_default_loop(),
@@ -112,10 +107,6 @@ TEST_IMPL(getaddrinfo_fail) {
 
 
 TEST_IMPL(getaddrinfo_fail_sync) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
   uv_getaddrinfo_t req;
 
   /* Use a FQDN by ending in a period */
@@ -133,11 +124,6 @@ TEST_IMPL(getaddrinfo_fail_sync) {
 
 
 TEST_IMPL(getaddrinfo_basic) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-
   int r;
   getaddrinfo_handle = (uv_getaddrinfo_t*)malloc(sizeof(uv_getaddrinfo_t));
 
@@ -159,10 +145,6 @@ TEST_IMPL(getaddrinfo_basic) {
 
 
 TEST_IMPL(getaddrinfo_basic_sync) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
   uv_getaddrinfo_t req;
 
   ASSERT_OK(uv_getaddrinfo(NULL,

test/test-getnameinfo.c

@@ -46,11 +46,6 @@ static void getnameinfo_req(uv_getnameinfo_t* handle,
 
 
 TEST_IMPL(getnameinfo_basic_ip4) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-
   int r;
 
   r = uv_ip4_addr(address_ip4, port, &addr4);
@@ -71,11 +66,6 @@ TEST_IMPL(getnameinfo_basic_ip4) {
 
 
 TEST_IMPL(getnameinfo_basic_ip4_sync) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-
   ASSERT_OK(uv_ip4_addr(address_ip4, port, &addr4));
 
   ASSERT_OK(uv_getnameinfo(uv_default_loop(),
@@ -92,11 +82,6 @@ TEST_IMPL(getnameinfo_basic_ip4_sync) {
 
 
 TEST_IMPL(getnameinfo_basic_ip6) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-  
   int r;
 
   r = uv_ip6_addr(address_ip6, port, &addr6);

test/test-tcp-write-after-connect.c

@@ -43,11 +43,6 @@ static void connect_cb(uv_connect_t *req, int status) {
 
 
 TEST_IMPL(tcp_write_after_connect) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-
   struct sockaddr_in sa;
   ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &sa));
   ASSERT_OK(uv_loop_init(&loop));

test/test-thread.c

@@ -163,11 +163,6 @@ TEST_IMPL(thread_create) {
  * that each "finished" callback is run in its originating thread.
  */
 TEST_IMPL(threadpool_multiple_event_loops) {
-/* TODO(gengjiawen): Fix test on QEMU. */
-#if defined(__QEMU__)
-  RETURN_SKIP("Test does not currently work in QEMU");
-#endif
-  
   struct test_thread threads[8];
   size_t i;
   int r;

test/test-tty.c

@@ -417,10 +417,10 @@ TEST_IMPL(tty_file) {
 }
 
 TEST_IMPL(tty_pty) {
-/* TODO(gengjiawen): Fix test on QEMU. */
+#if defined(__ASAN__)
-#if defined(__QEMU__)
+  RETURN_SKIP("Test does not currently work in ASAN");
-  RETURN_SKIP("Test does not currently work in QEMU");
 #endif
+
 #if defined(__APPLE__)                            || \
     defined(__DragonFly__)                        || \
     defined(__FreeBSD__)                          || \