gre-ilya/libuv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qemu testing

Browse Source
This commit is contained in:
Jameson Nash 2020-08-03 10:47:47 -04:00
parent 1899789be8
commit e8871535f5
14 changed files with 43 additions and 508 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
.github/workflows/CI-docs.yml vendored
View File

@ -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

33
.github/workflows/CI-sample.yml vendored
View File

@ -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

186
.github/workflows/CI-unix.yml vendored
View File

@ -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 }
- {target: armhf, toolchain: gcc-arm-linux-gnueabihf, cc: arm-linux-gnueabihf-gcc, qemu: qemu-arm }
- {target: aarch64, toolchain: gcc-aarch64-linux-gnu, cc: aarch64-linux-gnu-gcc, qemu: qemu-aarch64 }
- {target: riscv64, toolchain: gcc-riscv64-linux-gnu, cc: riscv64-linux-gnu-gcc, qemu: qemu-riscv64 }
- {target: ppc, toolchain: gcc-powerpc-linux-gnu, cc: powerpc-linux-gnu-gcc, qemu: qemu-ppc }
- {target: ppc64, toolchain: gcc-powerpc64-linux-gnu, cc: powerpc64-linux-gnu-gcc, qemu: qemu-ppc64 }
- {target: ppc64le, toolchain: gcc-powerpc64le-linux-gnu, cc: powerpc64le-linux-gnu-gcc, qemu: qemu-ppc64le }
- {target: s390x, toolchain: gcc-s390x-linux-gnu, cc: s390x-linux-gnu-gcc, qemu: qemu-s390x }
- {target: mips, toolchain: gcc-mips-linux-gnu, cc: mips-linux-gnu-gcc, qemu: qemu-mips }
- {target: mips64, toolchain: gcc-mips64-linux-gnuabi64, cc: mips64-linux-gnuabi64-gcc, qemu: qemu-mips64 }
- {target: mipsel, toolchain: gcc-mipsel-linux-gnu, cc: mipsel-linux-gnu-gcc, qemu: qemu-mipsel }
- {target: mips64el, toolchain: gcc-mips64el-linux-gnuabi64, cc: mips64el-linux-gnuabi64-gcc,qemu: 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 }
- {arch: arm, triple: arm-linux-gnueabi, qemu: arm, }
- {arch: armhf, triple: arm-linux-gnueabihf, qemu: arm, }
- {arch: aarch64, triple: aarch64-linux-gnu, qemu: aarch64, }
- {arch: riscv64, triple: riscv64-linux-gnu, qemu: riscv64, }
- {arch: ppc, triple: powerpc-linux-gnu, qemu: ppc, }
- {arch: ppc64, triple: powerpc64-linux-gnu, qemu: ppc64, }
- {arch: ppc64le, triple: powerpc64le-linux-gnu, qemu: ppc64le, }
- {arch: s390x, triple: s390x-linux-gnu, qemu: s390x, }
- {arch: mips, triple: mips-linux-gnu, qemu: mips, }
- {arch: mips64, triple: mips64-linux-gnuabi64, qemu: mips64, }
- {arch: mipsel, triple: mipsel-linux-gnu, qemu: mipsel, }
- {arch: mips64el, triple: mips64el-linux-gnuabi64, qemu: mips64el, }
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
- name: Configure with ${{ matrix.config.cc }}
sudo apt install ninja-build qemu-user qemu-user-binfmt gcc-${{ matrix.config.triple }} patchelf -y
# 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

128
.github/workflows/CI-win.yml vendored
View File

@ -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

104
.github/workflows/sanitizer.yml vendored
View File

@ -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

6
CMakeLists.txt
View File

@ -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} -static)
else()
target_link_libraries(uv_run_tests_a uv_a ${uv_test_libraries})
endif()
target_link_libraries(uv_run_tests_a uv_a ${uv_test_libraries})
add_test(NAME uv_test_a
COMMAND uv_run_tests_a
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

10
test/test-connection-fail.c
View File

@ -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);

5
test/test-get-currentexe.c
View File

@ -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;

5
test/test-get-passwd.c
View File

@ -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;

18
test/test-getaddrinfo.c
View File

@ -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,

15
test/test-getnameinfo.c
View File

@ -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);

5
test/test-tcp-write-after-connect.c
View File

@ -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));

5
test/test-thread.c
View File

@ -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;

6
test/test-tty.c
View File

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